mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
* fix(plugin): recover OMP stale catalog installations Refresh owned marketplace catalogs before reuse and validate the native cache identity when removing an installation. Preserve that identity through interrupted cleanup and report blocked batch updates as failures so retries remain safe and visible. * fix(plugin): preserve reviewed versions during OMP recovery Keep native removal identity separate from reviewed receipts so interrupted cleanup can retry safely. Expose isolated failures in previews and dry-run exit status while allowing healthy targets to proceed. * fix(plugin): resume interrupted OMP update cleanup Retry matching pending removals before reinstalling after registry-first interruption, and clarify isolated failure reporting. Strengthen recovery fixtures and restore accurate installation guidance. * test(plugin): model OMP cached catalog installs Use the cached marketplace entry for native install version and source so the stale catalog regression exercises the real version-to-cache relationship. * test(plugin): align OMP batch expectations with safety checks Require catalog refresh before reinstalling from an owned marketplace and assert isolated failures when native OMP ownership cannot be verified, while healthy targets update. * fix(plugin): skip native upgrade checks for OMP imports Imported plugins have no reviewed source to upgrade, so requiring native upgrade capability makes a safe batch skip fail unnecessarily. Cover that case and OMP dry-run failures, and align translations and native verification runbook with the failure and removal behavior. --------- Co-authored-by: Willie <egg358358@gmail.com>
1262 lines
52 KiB
Go
1262 lines
52 KiB
Go
package plugin
|
|
|
|
import (
|
|
"context"
|
|
"encoding/json"
|
|
"fmt"
|
|
"os"
|
|
"path/filepath"
|
|
"regexp"
|
|
"slices"
|
|
"strings"
|
|
"testing"
|
|
)
|
|
|
|
func fixture(t *testing.T) string {
|
|
t.Helper()
|
|
root := t.TempDir()
|
|
for name, content := range map[string]string{".claude-plugin/plugin.json": `{"name":"demo","version":"1.0.0"}`, ".codex-plugin/plugin.json": `{"name":"demo","version":"1.0.0","skills":"./skills"}`, "skills/demo/SKILL.md": "---\nname: demo\ndescription: Demo\n---\nHello"} {
|
|
p := filepath.Join(root, name)
|
|
if err := os.MkdirAll(filepath.Dir(p), 0755); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(p, []byte(content), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
return root
|
|
}
|
|
|
|
func TestDiscoverPreservesComponentsAndLeavesOutEscapes(t *testing.T) {
|
|
root := fixture(t)
|
|
d, err := Discover(context.Background(), root)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if len(d.Candidates) != 1 || len(d.Candidates[0].Targets) != 6 {
|
|
t.Fatalf("unexpected discovery: %+v", d)
|
|
}
|
|
if err := os.Symlink("/etc/passwd", filepath.Join(root, "escape")); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if escaped, err := Discover(context.Background(), root); err != nil || escaped.Digest != d.Digest || len(escaped.Warnings) != 1 {
|
|
t.Fatalf("external symlink not left out: %+v %v", escaped, err)
|
|
}
|
|
}
|
|
|
|
func TestNativeInventoryStrict(t *testing.T) {
|
|
for _, target := range []string{"claude", "codex"} {
|
|
if _, err := parseInventory(target, []byte(`{"unexpected":[]}`), ""); err == nil {
|
|
t.Fatal("unknown schema accepted")
|
|
}
|
|
}
|
|
items, err := parseInventory("codex", []byte(`{"installed":[{"pluginId":"demo@market","name":"demo","marketplaceName":"market","installed":true,"enabled":false,"version":"1"}],"available":[]}`), "")
|
|
if err != nil || len(items) != 1 || items[0].Enabled {
|
|
t.Fatalf("%+v %v", items, err)
|
|
}
|
|
}
|
|
|
|
func TestClaudeInventoryIgnoresOtherScopesBeforeValidating(t *testing.T) {
|
|
data := []byte(`[{"id":"demo@market","scope":"user"},{"id":"(suppressed)@skills-dir","scope":"project","projectPath":"/home/me"}]`)
|
|
items, err := parseInventory("claude", data, "")
|
|
if err != nil || len(items) != 1 || items[0].ID != "demo@market" {
|
|
t.Fatalf("%+v %v", items, err)
|
|
}
|
|
if _, err := parseInventory("claude", data, "/home/me"); err == nil {
|
|
t.Fatal("unsupported identifier in the active project accepted")
|
|
}
|
|
}
|
|
|
|
func TestPreviewCancelStaleAndPartialRetry(t *testing.T) {
|
|
root := fixture(t)
|
|
home := t.TempDir()
|
|
config := filepath.Join(home, "config.yaml")
|
|
if err := os.WriteFile(config, []byte("# keep me\nmode: merge\n"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
installed := map[string][]Installed{"claude": {}, "codex": {}}
|
|
failCodex := true
|
|
mutations := 0
|
|
runner := func(ctx context.Context, dir string, env []string, bin string, args ...string) ([]byte, error) {
|
|
joined := strings.Join(args, " ")
|
|
if joined == "--version" {
|
|
return []byte("test-version"), nil
|
|
}
|
|
if strings.Contains(joined, "--help") {
|
|
return []byte("install add remove uninstall update enable disable --json --scope"), nil
|
|
}
|
|
if joined == "plugin list --json" {
|
|
if bin == "codex" {
|
|
return json.Marshal(map[string]any{"installed": installed[bin], "available": []any{}})
|
|
}
|
|
return json.Marshal(installed[bin])
|
|
}
|
|
if joined == "plugin marketplace list --json" {
|
|
if bin == "codex" {
|
|
return []byte(`{"marketplaces":[]}`), nil
|
|
}
|
|
return []byte(`[]`), nil
|
|
}
|
|
mutations++
|
|
if bin == "codex" && failCodex {
|
|
return nil, fmt.Errorf("offline")
|
|
}
|
|
if len(args) > 2 && (args[1] == "install" || args[1] == "add") {
|
|
installed[bin] = append(installed[bin], Installed{ID: args[2], PluginID: args[2], Installed: true, Enabled: true, Scope: "user"})
|
|
}
|
|
return []byte(`{}`), nil
|
|
}
|
|
s := &Service{ConfigPath: config, StateDir: filepath.Join(home, "state"), Run: runner}
|
|
req := Request{Action: "add", Source: root, Plugin: "demo", Targets: []string{"claude", "codex"}}
|
|
p, err := s.Preview(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if mutations != 0 {
|
|
t.Fatal("preview mutated native state")
|
|
}
|
|
if _, err := os.Stat(s.StateDir); !os.IsNotExist(err) {
|
|
t.Fatal("preview created state")
|
|
}
|
|
if err := os.WriteFile(config, []byte("# changed\nmode: merge\n"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := s.Apply(context.Background(), req, p.Revision); err == nil {
|
|
t.Fatal("stale preview accepted")
|
|
}
|
|
p, err = s.Preview(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
result, err := s.Apply(context.Background(), req, p.Revision)
|
|
if err == nil || len(result.Results) != 2 {
|
|
t.Fatalf("expected partial result: %+v %v", result, err)
|
|
}
|
|
failCodex = false
|
|
req = Request{Action: "sync"}
|
|
p, err = s.Preview(context.Background(), req)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
before := mutations
|
|
result, err = s.Apply(context.Background(), req, p.Revision)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if mutations-before != 2 {
|
|
t.Fatalf("retry repeated successful target: %d", mutations-before)
|
|
}
|
|
data, _ := os.ReadFile(config)
|
|
if !strings.Contains(string(data), "# changed") {
|
|
t.Fatal("lost user comment")
|
|
}
|
|
}
|
|
|
|
func TestProjectCodexNeverFallsBackToGlobal(t *testing.T) {
|
|
s := &Service{ConfigPath: filepath.Join(t.TempDir(), "config.yaml"), ProjectRoot: t.TempDir(), StateDir: t.TempDir()}
|
|
p, err := s.Preview(context.Background(), Request{Action: "add", Source: fixture(t), Plugin: "demo", Targets: []string{"codex"}})
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if !p.Blocked {
|
|
t.Fatal("project Codex install was not blocked")
|
|
}
|
|
}
|
|
|
|
func TestSyncSelectionDoesNotToggleNativeEnabledState(t *testing.T) {
|
|
dir := t.TempDir()
|
|
config := filepath.Join(dir, "config.yaml")
|
|
err := os.WriteFile(config, []byte("plugins:\n packages:\n demo:\n bindings:\n codex:\n id: demo@market\n"), 0600)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
installed := true
|
|
mutations := []string{}
|
|
s := &Service{ConfigPath: config, StateDir: filepath.Join(dir, "state"), Run: func(ctx context.Context, dir string, env []string, target string, args ...string) ([]byte, error) {
|
|
joined := strings.Join(args, " ")
|
|
if joined == "--version" {
|
|
return []byte("0.154.0"), nil
|
|
}
|
|
if strings.Contains(joined, "--help") {
|
|
return []byte("--json"), nil
|
|
}
|
|
if joined == "plugin list --json" {
|
|
if installed {
|
|
return []byte(`{"installed":[{"pluginId":"demo@market","installed":true,"enabled":false}],"available":[]}`), nil
|
|
}
|
|
return []byte(`{"installed":[],"available":[]}`), nil
|
|
}
|
|
if joined == "plugin marketplace list --json" {
|
|
return []byte(`{"marketplaces":[{"name":"market","root":"/market"}]}`), nil
|
|
}
|
|
mutations = append(mutations, joined)
|
|
if strings.HasPrefix(joined, "plugin remove") {
|
|
installed = false
|
|
}
|
|
if strings.HasPrefix(joined, "plugin add") {
|
|
installed = true
|
|
}
|
|
return []byte(`{}`), nil
|
|
}}
|
|
apply := func(action string) {
|
|
t.Helper()
|
|
r := Request{Action: action, Name: "demo", Targets: []string{"codex"}}
|
|
p, e := s.Preview(context.Background(), r)
|
|
if e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
if _, e = s.Apply(context.Background(), r, p.Revision); e != nil {
|
|
t.Fatal(e)
|
|
}
|
|
}
|
|
apply("disable")
|
|
if len(mutations) != 0 || !installed {
|
|
t.Fatal("deselect changed native installation")
|
|
}
|
|
apply("sync")
|
|
if installed {
|
|
t.Fatal("sync did not remove excluded plugin")
|
|
}
|
|
d, err := s.load()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
b, ok := d.packages["demo"].Bindings["codex"]
|
|
if !ok || b.Selected() {
|
|
t.Fatal("excluded definition was lost")
|
|
}
|
|
apply("enable")
|
|
if installed {
|
|
t.Fatal("select installed immediately")
|
|
}
|
|
apply("sync")
|
|
if !installed {
|
|
t.Fatal("sync did not restore installation")
|
|
}
|
|
if len(mutations) != 2 || strings.Contains(strings.Join(mutations, " "), "enable") {
|
|
t.Fatalf("unexpected native mutation: %v", mutations)
|
|
}
|
|
}
|
|
|
|
func TestAddWithoutTargetsKeepsPackageForLater(t *testing.T) {
|
|
root := fixture(t)
|
|
s, installed, mutations := fakeClaude(t)
|
|
apply := func(r Request) *Plan {
|
|
t.Helper()
|
|
p, err := s.Preview(context.Background(), r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := s.Apply(context.Background(), r, p.Revision); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return p
|
|
}
|
|
writeFile(t, root, ".codex-plugin/plugin.json", `{"name":"demo","version":"1.0.0","skills":"./skills","interface":{"logo":"./logo.png"}}`)
|
|
writeFile(t, root, "logo.png", "png")
|
|
p := apply(Request{Action: "add", Source: root, Plugin: "demo"})
|
|
if len(p.Changes) != 1 || p.Changes[0].Action != "record" || *mutations != 0 {
|
|
t.Fatalf("add without targets touched an Agent: %+v %d", p.Changes, *mutations)
|
|
}
|
|
d, _ := s.load()
|
|
if pack, ok := d.packages["demo"]; !ok || pack.Source == "" || len(pack.Bindings) != 0 {
|
|
t.Fatalf("package not kept for later: %+v", d.packages)
|
|
}
|
|
if p.Changes[0].Logo != "data:image/png;base64,cG5n" {
|
|
t.Fatalf("preview lost the Codex logo: %q", p.Changes[0].Logo)
|
|
}
|
|
if d.packages["demo"].Version != "1.0.0" {
|
|
t.Fatalf("lost local reviewed version: %+v", d.packages["demo"])
|
|
}
|
|
shared, err := decodeDocument(d.raw, nil)
|
|
if err != nil || len(shared.legacy) != 0 || shared.intent["demo"].Source != root {
|
|
t.Fatalf("shared intent cached local metadata: %s %v", d.raw, err)
|
|
}
|
|
apply(Request{Action: "add", Name: "demo", Source: root, Plugin: "demo", Targets: []string{"claude"}})
|
|
apply(Request{Action: "remove", Name: "demo", Targets: []string{"claude"}})
|
|
if d, _ = s.load(); len(*installed) != 0 || d.packages["demo"].Source == "" {
|
|
t.Fatalf("removing the last Agent dropped the package: %+v %+v", *installed, d.packages)
|
|
}
|
|
apply(Request{Action: "remove", Name: "demo"})
|
|
if d, _ = s.load(); len(d.packages) != 0 {
|
|
t.Fatalf("remove kept the package: %+v", d.packages)
|
|
}
|
|
}
|
|
|
|
// fakeClaude answers like a Claude Code CLI with an empty inventory, and counts the calls that change it.
|
|
func fakeClaude(t *testing.T) (*Service, *[]Installed, *int) {
|
|
home := t.TempDir()
|
|
installed := []Installed{}
|
|
mutations := 0
|
|
s := &Service{ConfigPath: filepath.Join(home, "config.yaml"), StateDir: filepath.Join(home, "state"), Run: func(ctx context.Context, dir string, env []string, bin string, args ...string) ([]byte, error) {
|
|
joined := strings.Join(args, " ")
|
|
switch {
|
|
case joined == "--version":
|
|
return []byte("test-version"), nil
|
|
case strings.Contains(joined, "--help"):
|
|
return []byte("install add remove uninstall update enable disable --json --scope"), nil
|
|
case joined == "plugin list --json":
|
|
return json.Marshal(installed)
|
|
case joined == "plugin marketplace list --json":
|
|
return []byte(`[]`), nil
|
|
}
|
|
mutations++
|
|
if len(args) > 2 && args[1] == "install" {
|
|
installed = append(installed, Installed{ID: args[2], PluginID: args[2], Installed: true, Enabled: true, Scope: "user"})
|
|
}
|
|
if len(args) > 2 && args[1] == "uninstall" {
|
|
installed = []Installed{}
|
|
}
|
|
return []byte(`{}`), nil
|
|
}}
|
|
return s, &installed, &mutations
|
|
}
|
|
|
|
func TestCheckReportsTheSourceVersion(t *testing.T) {
|
|
root := fixture(t)
|
|
s, _, _ := fakeClaude(t)
|
|
r := Request{Action: "add", Source: root, Plugin: "demo", Targets: []string{"claude"}}
|
|
p, err := s.Preview(context.Background(), r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := s.Apply(context.Background(), r, p.Revision); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(root, ".claude-plugin/plugin.json"), []byte(`{"name":"demo","version":"1.1.0"}`), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
p, err = s.Preview(context.Background(), Request{Action: "check"})
|
|
if err != nil || len(p.Changes) != 1 || p.Changes[0].Action != "update-available" || p.Changes[0].Binding.Version != "1.1.0" {
|
|
t.Fatalf("check did not report the new version: %+v %v", p, err)
|
|
}
|
|
}
|
|
|
|
// A local directory has no commit: the digest is all that tells the content the check saw
|
|
// from what an update would install, so the check must carry it.
|
|
func TestCheckCarriesTheSourceDigestTheUpdateWouldInstall(t *testing.T) {
|
|
root := fixture(t)
|
|
s, _, _ := fakeClaude(t)
|
|
r := Request{Action: "add", Source: root, Plugin: "demo", Targets: []string{"claude"}}
|
|
p, err := s.Preview(context.Background(), r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := s.Apply(context.Background(), r, p.Revision); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if err := os.WriteFile(filepath.Join(root, "skills", "extra.md"), []byte("changed"), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
check, err := s.Preview(context.Background(), Request{Action: "check"})
|
|
if err != nil || len(check.Changes) != 1 || check.Changes[0].Action != "update-available" {
|
|
t.Fatalf("check did not report the change: %+v %v", check, err)
|
|
}
|
|
update, err := s.Preview(context.Background(), Request{Action: "update", Name: "demo", Targets: []string{"claude"}})
|
|
if err != nil || len(update.Changes) != 1 {
|
|
t.Fatalf("update preview: %+v %v", update, err)
|
|
}
|
|
if got, want := check.Changes[0].Binding.Digest, update.Changes[0].Binding.Digest; got == "" || got != want {
|
|
t.Fatalf("check digest %q, update digest %q", got, want)
|
|
}
|
|
}
|
|
|
|
func TestManagedMarketplaceNameShowsThePlugin(t *testing.T) {
|
|
root := fixture(t)
|
|
for _, manifest := range []string{".claude-plugin/plugin.json", ".codex-plugin/plugin.json"} {
|
|
if err := os.WriteFile(filepath.Join(root, manifest), []byte(`{"name":"my.demo","version":"1.0.0"}`), 0644); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
}
|
|
s, _, _ := fakeClaude(t)
|
|
p, err := s.Preview(context.Background(), Request{Action: "add", Source: root, Plugin: "my.demo", Targets: []string{"claude"}})
|
|
if err != nil || len(p.Changes) != 1 {
|
|
t.Fatalf("preview failed: %+v %v", p, err)
|
|
}
|
|
// Codex rejects marketplace names outside ASCII letters, digits, `_`, and `-`.
|
|
if id := p.Changes[0].ID; !regexp.MustCompile(`^my\.demo@skillshare-my-demo-[0-9a-f]{16}$`).MatchString(id) {
|
|
t.Fatalf("marketplace name does not show the plugin: %s", id)
|
|
}
|
|
}
|
|
|
|
func TestFailedNativeCommandOutcomeCarriesItsKey(t *testing.T) {
|
|
s, _, _ := fakeClaude(t)
|
|
run := s.Run
|
|
s.Run = func(ctx context.Context, dir string, env []string, bin string, args ...string) ([]byte, error) {
|
|
if len(args) > 1 && args[1] == "install" && !slices.Contains(args, "--help") {
|
|
return nil, agentError{key: "plugins.error.commandFailed", message: "claude command failed"}
|
|
}
|
|
return run(ctx, dir, env, bin, args...)
|
|
}
|
|
r := Request{Action: "add", Source: fixture(t), Plugin: "demo", Targets: []string{"claude"}}
|
|
p, err := s.Preview(context.Background(), r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
result, err := s.Apply(context.Background(), r, p.Revision)
|
|
if result == nil || len(result.Results) != 1 || result.Results[0].MessageKey != "plugins.error.commandFailed" {
|
|
t.Fatalf("failed outcome lost its translation key: %+v %v", result, err)
|
|
}
|
|
}
|
|
|
|
func TestExcludingAManagedPluginRemovesItsMarketplace(t *testing.T) {
|
|
agents := &fakeAgents{version: "1.0.0"}
|
|
s := agents.service(t)
|
|
applyPluginRequest(t, s, Request{Action: "add", Source: fixture(t), Targets: []string{"claude", "codex"}})
|
|
if len(agents.markets["claude"]) != 1 || len(agents.markets["codex"]) != 1 {
|
|
t.Fatalf("install did not register marketplaces: %v", agents.markets)
|
|
}
|
|
applyPluginRequest(t, s, Request{Action: "disable", Name: "demo", Targets: []string{"claude", "codex"}})
|
|
applyPluginRequest(t, s, Request{Action: "sync"})
|
|
if len(agents.markets["claude"]) != 0 || len(agents.markets["codex"]) != 0 {
|
|
t.Fatalf("Skillshare marketplaces were left behind: %v", agents.markets)
|
|
}
|
|
}
|
|
|
|
func TestAddingAClaudePluginNamedLikeASkillFolderExplainsTheClash(t *testing.T) {
|
|
agents := &fakeAgents{installed: map[string][]Installed{"claude": {{ID: "demo@skills-dir", PluginID: "demo@skills-dir", Installed: true, Enabled: true, Scope: "user"}}}}
|
|
s := agents.service(t)
|
|
p, err := s.Preview(context.Background(), Request{Action: "add", Source: fixture(t), Targets: []string{"claude"}})
|
|
if err != nil || len(p.Changes) != 1 || p.Changes[0].Action != "install" || p.Changes[0].MessageKey != "plugins.note.skillsDirClash" {
|
|
t.Fatalf("preview did not explain the skill folder clash: %+v %v", p, err)
|
|
}
|
|
}
|
|
|
|
// legacyBinding records a plugin under the older skillshare-<hash> marketplace name, whose
|
|
// marketplace is still registered although the plugin itself is gone.
|
|
func legacyBinding(t *testing.T, s *Service, agents *fakeAgents, extra string) Binding {
|
|
t.Helper()
|
|
b := Binding{ID: "demo@skillshare-0123456789abcdef", Source: "https://example.com/demo", Plugin: "demo"}
|
|
writePluginFile(t, filepath.Dir(s.ConfigPath), "config.yaml", "plugins:\n packages:\n demo:\n bindings:\n claude:\n id: "+b.ID+"\n source: "+b.Source+"\n plugin: demo\n"+extra)
|
|
agents.market("claude")["skillshare-0123456789abcdef"] = s.snapshotPath(b, "claude")
|
|
seedLocalBinding(t, s, "demo", "claude", b)
|
|
return b
|
|
}
|
|
|
|
func TestExcludingAPluginAlreadyGoneStillRemovesItsMarketplace(t *testing.T) {
|
|
agents := &fakeAgents{}
|
|
s := agents.service(t)
|
|
legacyBinding(t, s, agents, " sync: false\n")
|
|
p, err := s.Preview(context.Background(), Request{Action: "sync"})
|
|
if err != nil || len(p.Changes) != 1 || p.Changes[0].Action != "uninstall" || p.Changes[0].MessageKey != "plugins.note.marketplaceCleanup" {
|
|
t.Fatalf("sync did not plan the marketplace cleanup: %+v %v", p, err)
|
|
}
|
|
applyPluginRequest(t, s, Request{Action: "sync"})
|
|
if len(agents.markets["claude"]) != 0 || !slices.Equal(agents.commands, []string{"claude plugin marketplace remove skillshare-0123456789abcdef"}) {
|
|
t.Fatalf("cleanup ran %q, left %v", agents.commands, agents.markets)
|
|
}
|
|
}
|
|
|
|
func TestRemovingAPluginAlreadyGoneRemovesItsMarketplace(t *testing.T) {
|
|
agents := &fakeAgents{}
|
|
s := agents.service(t)
|
|
legacyBinding(t, s, agents, "")
|
|
applyPluginRequest(t, s, Request{Action: "remove", Name: "demo"})
|
|
inv, err := s.Packages()
|
|
if err != nil || len(agents.markets["claude"]) != 0 || len(inv.Packages) != 0 {
|
|
t.Fatalf("remove left %v, packages %v, err %v", agents.markets, inv, err)
|
|
}
|
|
}
|
|
|
|
func TestFailedMarketplaceCleanupIsRetriedOnTheNextSync(t *testing.T) {
|
|
agents := &fakeAgents{version: "1.0.0"}
|
|
s := agents.service(t)
|
|
applyPluginRequest(t, s, Request{Action: "add", Source: fixture(t), Targets: []string{"claude"}})
|
|
applyPluginRequest(t, s, Request{Action: "disable", Name: "demo", Targets: []string{"claude"}})
|
|
agents.failRemove = 1
|
|
r := Request{Action: "sync"}
|
|
p, err := s.Preview(context.Background(), r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
result, _ := s.Apply(context.Background(), r, p.Revision)
|
|
if result == nil || len(result.Results) != 1 || result.Results[0].MessageKey != "plugins.error.marketplaceCleanup" {
|
|
t.Fatalf("cleanup failure was not reported: %+v", result)
|
|
}
|
|
applyPluginRequest(t, s, r)
|
|
if len(agents.markets["claude"]) != 0 {
|
|
t.Fatalf("retry left %v", agents.markets)
|
|
}
|
|
}
|
|
|
|
func TestMarketplaceStillRegisteredAfterRemovalIsReported(t *testing.T) {
|
|
agents := &fakeAgents{stuck: true}
|
|
s := agents.service(t)
|
|
legacyBinding(t, s, agents, " sync: false\n")
|
|
r := Request{Action: "sync"}
|
|
p, err := s.Preview(context.Background(), r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := s.Apply(context.Background(), r, p.Revision); err == nil {
|
|
t.Fatal("a marketplace that survived removal was reported as removed")
|
|
}
|
|
}
|
|
|
|
func TestForeignMarketplaceWithTheSameNameIsLeftAlone(t *testing.T) {
|
|
agents := &fakeAgents{}
|
|
s := agents.service(t)
|
|
legacyBinding(t, s, agents, " sync: false\n")
|
|
agents.market("claude")["skillshare-0123456789abcdef"] = "/elsewhere"
|
|
applyPluginRequest(t, s, Request{Action: "sync"})
|
|
if len(agents.commands) != 0 || agents.markets["claude"]["skillshare-0123456789abcdef"] != "/elsewhere" {
|
|
t.Fatalf("foreign marketplace was touched: %q %v", agents.commands, agents.markets)
|
|
}
|
|
}
|
|
|
|
func TestRemoveKeepsTheBindingWhileMarketplacesAreUnknown(t *testing.T) {
|
|
agents := &fakeAgents{}
|
|
s := agents.service(t)
|
|
legacyBinding(t, s, agents, "")
|
|
run := s.Run
|
|
s.Run = func(ctx context.Context, dir string, env []string, bin string, args ...string) ([]byte, error) {
|
|
if strings.Join(args, " ") == "plugin marketplace list --json" {
|
|
return []byte(`not json`), nil
|
|
}
|
|
return run(ctx, dir, env, bin, args...)
|
|
}
|
|
r := Request{Action: "remove", Name: "demo"}
|
|
p, err := s.Preview(context.Background(), r)
|
|
if err != nil || len(p.Changes) == 0 || p.Changes[0].Action != "remove" {
|
|
t.Fatalf("remove forgot a binding whose marketplace may remain: %+v %v", p, err)
|
|
}
|
|
_, _ = s.Apply(context.Background(), r, p.Revision)
|
|
if inv, err := s.Packages(); err != nil || len(inv.Packages) != 1 {
|
|
t.Fatalf("binding was dropped before its marketplace cleanup: %+v %v", inv, err)
|
|
}
|
|
}
|
|
|
|
func TestHostReportsOnlyItsOwnManagedMarketplaces(t *testing.T) {
|
|
agents := &fakeAgents{}
|
|
s := agents.service(t)
|
|
b := legacyBinding(t, s, agents, "")
|
|
agents.market("claude")["skillshare-foreign"] = "/elsewhere/skillshare-foreign"
|
|
agents.market("claude")["team"] = filepath.Join(filepath.Dir(s.snapshotPath(b, "claude")), "team")
|
|
if got := s.host(context.Background(), "claude").ManagedMarketplaces; !slices.Equal(got, []string{"skillshare-0123456789abcdef"}) {
|
|
t.Fatalf("managed marketplaces = %v", got)
|
|
}
|
|
}
|
|
|
|
func TestMarketplaceAlsoDeclaredAtAnotherPathIsNotRemoved(t *testing.T) {
|
|
agents := &fakeAgents{}
|
|
s := agents.service(t)
|
|
b := legacyBinding(t, s, agents, " sync: false\n")
|
|
run := s.Run
|
|
s.Run = func(ctx context.Context, dir string, env []string, bin string, args ...string) ([]byte, error) {
|
|
if strings.Join(args, " ") == "plugin marketplace list --json" {
|
|
return json.Marshal([]map[string]string{{"name": "skillshare-0123456789abcdef", "installLocation": s.snapshotPath(b, "claude")}, {"name": "skillshare-0123456789abcdef", "installLocation": "/elsewhere"}})
|
|
}
|
|
return run(ctx, dir, env, bin, args...)
|
|
}
|
|
r := Request{Action: "sync"}
|
|
p, err := s.Preview(context.Background(), r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
result, _ := s.Apply(context.Background(), r, p.Revision)
|
|
if slices.ContainsFunc(agents.commands, func(c string) bool { return strings.Contains(c, "marketplace remove") }) || result == nil || len(result.Results) != 1 || result.Results[0].MessageKey != "plugins.error.marketplaceCleanup" {
|
|
t.Fatalf("removed a marketplace also declared elsewhere: %q %+v", agents.commands, result)
|
|
}
|
|
}
|
|
|
|
func TestSyncSkipsAnImportWhoseNativeMarketplaceIsGone(t *testing.T) {
|
|
agents := &fakeAgents{installed: map[string][]Installed{"claude": {{ID: "demo@team", Scope: "user", Installed: true}}}, markets: map[string]map[string]string{"claude": {"team": "/team"}}}
|
|
s := agents.service(t)
|
|
applyPluginRequest(t, s, Request{Action: "import", From: "claude", Plugin: "demo@team"})
|
|
if b := readState(t, s).state.Bindings["demo"]["claude"]; b.Applied == nil || b.Applied.Binding.ID != "demo@team" || b.Legacy != nil {
|
|
t.Fatal("fixture lacks a locally owned imported receipt")
|
|
}
|
|
delete(agents.market("claude"), "team")
|
|
agents.installed["claude"] = nil
|
|
|
|
p, err := s.Preview(context.Background(), Request{Action: "sync"})
|
|
if err != nil || p.Blocked || len(p.Changes) != 1 || p.Changes[0].Action != "skip" || p.Changes[0].MessageKey != "plugins.skip.marketplaceGone" {
|
|
t.Fatalf("sync did not skip the import: %+v %v", p, err)
|
|
}
|
|
applyPluginRequest(t, s, Request{Action: "sync"})
|
|
if len(agents.commands) != 0 {
|
|
t.Fatalf("skipped import still ran %q", agents.commands)
|
|
}
|
|
}
|
|
|
|
func TestUpdateRegistersAMissingManagedMarketplaceAgain(t *testing.T) {
|
|
agents := &fakeAgents{version: "1.0.0"}
|
|
s := agents.service(t)
|
|
source := fixture(t)
|
|
applyPluginRequest(t, s, Request{Action: "add", Source: source, Targets: []string{"claude"}})
|
|
agents.markets["claude"] = nil
|
|
bumpDemo(t, source, agents)
|
|
applyPluginRequest(t, s, Request{Action: "update", Name: "demo", Targets: []string{"claude"}})
|
|
if len(agents.markets["claude"]) != 1 || !strings.HasPrefix(agents.commands[0], "claude plugin marketplace add ") {
|
|
t.Fatalf("update did not register the marketplace again: %q", agents.commands)
|
|
}
|
|
}
|
|
|
|
// homeFixture places the fixture under HOME so its source can be spelled ~/plug.
|
|
func homeFixture(t *testing.T) string {
|
|
t.Helper()
|
|
source := filepath.Join(os.Getenv("HOME"), "plug")
|
|
if err := os.CopyFS(source, os.DirFS(fixture(t))); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return source
|
|
}
|
|
|
|
func TestSavingPluginsWritesThroughASymlinkedConfig(t *testing.T) {
|
|
agents := &fakeAgents{version: "1.0.0"}
|
|
s := agents.service(t)
|
|
shared := filepath.Join(os.Getenv("HOME"), "dotfiles", "skillshare.yaml")
|
|
writeFile(t, filepath.Dir(shared), "skillshare.yaml", "preserve_tilde_on_save: true\n")
|
|
if err := os.Symlink(shared, s.ConfigPath); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
applyPluginRequest(t, s, Request{Action: "add", Source: homeFixture(t), Targets: []string{"claude"}})
|
|
if info, err := os.Lstat(s.ConfigPath); err != nil || info.Mode()&os.ModeSymlink == 0 {
|
|
t.Fatalf("config.yaml is no longer a symlink: %v", err)
|
|
}
|
|
data, _ := os.ReadFile(shared)
|
|
if !strings.Contains(string(data), "source: ~/plug") || strings.Contains(string(data), os.Getenv("HOME")) {
|
|
t.Fatalf("shared config not updated with a ~ source:\n%s", data)
|
|
}
|
|
}
|
|
|
|
func TestUpdateAcceptsASourceSpelledWithTilde(t *testing.T) {
|
|
agents := &fakeAgents{version: "1.0.0"}
|
|
s := agents.service(t)
|
|
source := homeFixture(t)
|
|
applyPluginRequest(t, s, Request{Action: "add", Source: source, Targets: []string{"claude"}})
|
|
data, _ := os.ReadFile(s.ConfigPath)
|
|
writeFile(t, filepath.Dir(s.ConfigPath), "config.yaml", strings.ReplaceAll(string(data), source, "~/plug"))
|
|
bumpDemo(t, source, agents)
|
|
applyPluginRequest(t, s, Request{Action: "update", Name: "demo", Targets: []string{"claude"}})
|
|
}
|
|
|
|
func TestRecordedSourceDoesNotBlockAnotherDistribution(t *testing.T) {
|
|
s, _, _ := fakeClaude(t)
|
|
r := Request{Action: "add", Source: fixture(t), Plugin: "demo"}
|
|
p, err := s.Preview(context.Background(), r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if _, err := s.Apply(context.Background(), r, p.Revision); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
p, err = s.Preview(context.Background(), Request{Action: "add", Source: fixture(t), Plugin: "demo", Name: "demo", Targets: []string{"claude"}})
|
|
if err != nil || p.Blocked {
|
|
t.Fatalf("another source for one Agent was blocked: %+v %v", p, err)
|
|
}
|
|
}
|
|
|
|
// fakeAgents installs plugins like Claude and Codex: installing or updating puts the
|
|
// marketplace's current version in place, and Codex's add always enables the plugin.
|
|
type fakeAgents struct {
|
|
version string
|
|
installed map[string][]Installed
|
|
// markets maps each Agent to the root of every marketplace registered with it.
|
|
markets map[string]map[string]string
|
|
// failRemove fails that many marketplace removals; stuck keeps the registration anyway,
|
|
// as a copy declared in another Claude settings scope does.
|
|
failRemove int
|
|
stuck bool
|
|
commands []string
|
|
}
|
|
|
|
func (f *fakeAgents) market(bin string) map[string]string {
|
|
if f.markets[bin] == nil {
|
|
f.markets[bin] = map[string]string{}
|
|
}
|
|
return f.markets[bin]
|
|
}
|
|
|
|
func (f *fakeAgents) service(t *testing.T) *Service {
|
|
t.Helper()
|
|
home := t.TempDir()
|
|
t.Setenv("HOME", home)
|
|
if f.installed == nil {
|
|
f.installed = map[string][]Installed{}
|
|
}
|
|
if f.markets == nil {
|
|
f.markets = map[string]map[string]string{}
|
|
}
|
|
s := &Service{ConfigPath: filepath.Join(home, "config.yaml"), StateDir: filepath.Join(home, "state")}
|
|
s.Run = func(_ context.Context, dir string, _ []string, bin string, args ...string) ([]byte, error) {
|
|
command := strings.Join(args, " ")
|
|
switch {
|
|
case command == "--version":
|
|
if bin == "omp" {
|
|
return []byte("omp/18.8.7"), nil
|
|
}
|
|
return []byte("test"), nil
|
|
case strings.Contains(command, "--help"):
|
|
return []byte("--json --scope upgrade"), nil
|
|
case command == "plugin list --json" && bin == "codex":
|
|
return json.Marshal(map[string]any{"installed": f.installed[bin], "available": []any{}})
|
|
case command == "plugin list --json" && bin == "omp":
|
|
// omp plugin list --json: npm/link plugins, then marketplace summaries per scope.
|
|
npm, market := []map[string]any{}, []map[string]any{}
|
|
for _, i := range f.installed[bin] {
|
|
if !validID(i.ID) {
|
|
npm = append(npm, map[string]any{"name": i.ID, "version": i.Version, "enabled": i.Enabled, "manifest": map[string]any{}})
|
|
continue
|
|
}
|
|
scope := i.Scope
|
|
if scope == "" {
|
|
scope = "user"
|
|
}
|
|
market = append(market, map[string]any{"id": i.ID, "scope": scope, "entries": []map[string]any{{"scope": scope, "installPath": ompCachePath(filepath.Join(os.Getenv("HOME"), ".omp/plugins/cache/plugins"), i.ID, i.Version), "version": i.Version, "enabled": i.Enabled}}})
|
|
}
|
|
return json.Marshal(map[string]any{"npm": npm, "marketplace": market})
|
|
case command == "plugin marketplace list" && bin == "omp":
|
|
var text strings.Builder
|
|
text.WriteString("Configured Marketplaces:\n\n")
|
|
for name, root := range f.market(bin) {
|
|
text.WriteString(" \x1b[36m" + name + "\x1b[39m \x1b[2m" + root + "\x1b[22m\n")
|
|
}
|
|
return []byte(text.String()), nil
|
|
case command == "plugin list --json":
|
|
return json.Marshal(append([]Installed{}, f.installed[bin]...))
|
|
case command == "plugin marketplace list --json":
|
|
list := []map[string]string{}
|
|
for name, root := range f.market(bin) {
|
|
if bin == "codex" {
|
|
list = append(list, map[string]string{"name": name, "root": root})
|
|
} else {
|
|
list = append(list, map[string]string{"name": name, "installLocation": root})
|
|
}
|
|
}
|
|
if bin == "codex" {
|
|
return json.Marshal(map[string]any{"marketplaces": list})
|
|
}
|
|
return json.Marshal(list)
|
|
}
|
|
f.commands = append(f.commands, bin+" "+command)
|
|
switch {
|
|
case args[1] == "marketplace" && args[2] == "add":
|
|
f.market(bin)[filepath.Base(args[3])] = args[3]
|
|
case args[1] == "marketplace" && args[2] == "remove":
|
|
if f.failRemove > 0 {
|
|
f.failRemove--
|
|
return nil, agentError{key: "plugins.error.commandFailed", message: bin + " command failed"}
|
|
}
|
|
// Like Claude, a scoped removal fails when only known_marketplaces.json records it.
|
|
if slices.Contains(args, "--scope") {
|
|
return nil, agentError{key: "plugins.error.commandFailed", message: "Marketplace '" + args[3] + "' is not declared in user settings"}
|
|
}
|
|
if !f.stuck {
|
|
delete(f.market(bin), args[3])
|
|
}
|
|
case args[1] == "add" || args[1] == "install" || args[1] == "update" || args[1] == "upgrade":
|
|
scope := "user"
|
|
if i := slices.Index(args, "--scope"); i >= 0 {
|
|
scope = args[i+1]
|
|
}
|
|
enabled := true
|
|
// OMP's upgrade reinstalls from the marketplace and keeps a disabled plugin disabled.
|
|
if args[1] == "upgrade" {
|
|
for _, i := range f.installed[bin] {
|
|
if i.ID == args[2] {
|
|
enabled = i.Enabled
|
|
}
|
|
}
|
|
}
|
|
f.installed[bin] = []Installed{{ID: args[2], PluginID: args[2], Installed: true, Enabled: enabled, Version: f.version, Scope: scope, ProjectPath: dir}}
|
|
case args[1] == "remove" || args[1] == "uninstall":
|
|
f.installed[bin] = nil
|
|
}
|
|
return []byte(`{}`), nil
|
|
}
|
|
return s
|
|
}
|
|
|
|
// bumpDemo releases version 2.0.0 of the fixture's plugin.
|
|
func bumpDemo(t *testing.T, source string, agents *fakeAgents) {
|
|
t.Helper()
|
|
writeFile(t, source, ".claude-plugin/plugin.json", `{"name":"demo","version":"2.0.0"}`)
|
|
writeFile(t, source, ".codex-plugin/plugin.json", `{"name":"demo","version":"2.0.0","skills":"./skills"}`)
|
|
agents.version, agents.commands = "2.0.0", nil
|
|
}
|
|
|
|
// Codex has no update command, so an update adds the plugin again from the new snapshot.
|
|
func TestCodexUpdateAddsThePluginAgain(t *testing.T) {
|
|
agents := &fakeAgents{version: "1.0.0"}
|
|
s := agents.service(t)
|
|
source := fixture(t)
|
|
applyPluginRequest(t, s, Request{Action: "add", Source: source, Targets: []string{"codex"}})
|
|
bumpDemo(t, source, agents)
|
|
applyPluginRequest(t, s, Request{Action: "update", Name: "demo", Targets: []string{"codex"}})
|
|
if len(agents.commands) != 1 || !strings.HasPrefix(agents.commands[0], "codex plugin add demo@") {
|
|
t.Fatalf("commands: %q", agents.commands)
|
|
}
|
|
}
|
|
|
|
// Codex installs a Claude-only package from the snapshot as it is; Skillshare writes no Codex manifest.
|
|
func TestCodexAddsAClaudeOnlyPackageUnchanged(t *testing.T) {
|
|
agents := &fakeAgents{version: "1.3.2"}
|
|
s := agents.service(t)
|
|
source := t.TempDir()
|
|
files := map[string]string{
|
|
".claude-plugin/plugin.json": `{"name":"skills","version":"1.3.2","skills":["./skills/tdd"]}`,
|
|
"skills/tdd/SKILL.md": "---\nname: tdd\ndescription: TDD\n---\nRead references/guide.md and ../../docs/shared.md.\n",
|
|
"skills/tdd/references/guide.md": "Required skill reference.\n",
|
|
"skills/tdd/agents/openai.yaml": "policy:\n allow_implicit_invocation: false\n",
|
|
"docs/shared.md": "Required package-level resource.\n",
|
|
}
|
|
for path, data := range files {
|
|
writeFile(t, source, path, data)
|
|
}
|
|
r := Request{Action: "add", Source: source, Targets: []string{"codex"}}
|
|
p, err := s.Preview(context.Background(), r)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
i := slices.IndexFunc(p.Changes, func(c Change) bool { return c.Target == "codex" && c.Action == "install" })
|
|
if p.Blocked || i < 0 || p.Changes[i].Binding.Version != "1.3.2" || !slices.Equal(p.Changes[i].Binding.Components, []string{"skills"}) {
|
|
t.Fatalf("Codex plan: %+v", p.Changes)
|
|
}
|
|
applyPluginRequest(t, s, r)
|
|
if len(agents.markets["codex"]) != 1 || len(agents.installed["codex"]) != 1 {
|
|
t.Fatalf("not installed: %+v %+v", agents.markets, agents.installed)
|
|
}
|
|
for _, snapshot := range agents.markets["codex"] {
|
|
for path, want := range files {
|
|
if got, err := os.ReadFile(filepath.Join(snapshot, "content", path)); err != nil || string(got) != want {
|
|
t.Fatalf("package file %s changed: %q %v", path, got, err)
|
|
}
|
|
}
|
|
if _, err := os.Lstat(filepath.Join(snapshot, "content", ".codex-plugin")); !os.IsNotExist(err) {
|
|
t.Fatalf("Codex manifest written: %v", err)
|
|
}
|
|
}
|
|
}
|
|
|
|
// Adding would turn a plugin disabled in Codex back on, so the update skips it, and the
|
|
// other Agents of the plugin are still updated.
|
|
func TestCodexUpdateSkipsADisabledPlugin(t *testing.T) {
|
|
agents := &fakeAgents{version: "1.0.0"}
|
|
s := agents.service(t)
|
|
source := fixture(t)
|
|
applyPluginRequest(t, s, Request{Action: "add", Source: source, Targets: []string{"claude", "codex"}})
|
|
agents.installed["codex"][0].Enabled = false
|
|
bumpDemo(t, source, agents)
|
|
applyPluginRequest(t, s, Request{Action: "update", Name: "demo", Targets: []string{"claude", "codex"}})
|
|
if slices.ContainsFunc(agents.commands, func(c string) bool { return strings.HasPrefix(c, "codex ") }) || !slices.Contains(agents.commands, "claude plugin update "+agents.installed["claude"][0].ID+" --scope user --json") {
|
|
t.Fatalf("commands: %q", agents.commands)
|
|
}
|
|
}
|
|
|
|
// An imported plugin has no reviewed source; Codex upgrades it with its marketplace.
|
|
func TestCodexUpdateOfAnImportUpgradesItsMarketplace(t *testing.T) {
|
|
agents := &fakeAgents{installed: map[string][]Installed{"codex": {{PluginID: "demo@team", Installed: true, Enabled: true, Version: "1.0.0"}}}, markets: map[string]map[string]string{"codex": {"team": "/team"}}}
|
|
s := agents.service(t)
|
|
applyPluginRequest(t, s, Request{Action: "import", From: "codex", Plugin: "demo@team"})
|
|
agents.commands = nil
|
|
applyPluginRequest(t, s, Request{Action: "update", Name: "demo", Targets: []string{"codex"}})
|
|
if !slices.Equal(agents.commands, []string{"codex plugin marketplace upgrade team"}) {
|
|
t.Fatalf("commands: %q", agents.commands)
|
|
}
|
|
}
|
|
|
|
// importedDemo imports demo@team from Claude into a package that also has a source, as when
|
|
// another Agent was added from it, and leaves the Claude update pending at 1.0.0.
|
|
func importedDemo(t *testing.T) (*Service, *fakeAgents) {
|
|
t.Helper()
|
|
agents := &fakeAgents{version: "2.0.0", installed: map[string][]Installed{"claude": {{ID: "demo@team", PluginID: "demo@team", Installed: true, Enabled: true, Version: "1.0.0", Scope: "user"}}}, markets: map[string]map[string]string{"claude": {"team": "/team"}}}
|
|
s := agents.service(t)
|
|
applyPluginRequest(t, s, Request{Action: "import", From: "claude", Plugin: "demo@team"})
|
|
source := fixture(t)
|
|
applyPluginRequest(t, s, Request{Action: "add", Name: "demo", Source: source})
|
|
run := s.Run
|
|
s.Run = func(ctx context.Context, dir string, env []string, bin string, args ...string) ([]byte, error) {
|
|
if bin == "claude" && len(args) > 1 && args[0] == "plugin" && args[1] == "update" && !slices.Contains(args, "--help") {
|
|
return nil, fmt.Errorf("native update failed")
|
|
}
|
|
return run(ctx, dir, env, bin, args...)
|
|
}
|
|
applyFailure(t, s, Request{Action: "update", Name: "demo", Targets: []string{"claude"}})
|
|
s.Run = run
|
|
cfg := readState(t, s)
|
|
pack := cfg.packages["demo"]
|
|
local := cfg.state.Bindings["demo"]["claude"]
|
|
if pack.Source != source || pack.Bindings["claude"].Source != "" || !pack.Bindings["claude"].Imported {
|
|
t.Fatal("fixture lacks source intent with an imported Claude override")
|
|
}
|
|
if local.Applied == nil || local.Pending == nil || local.Pending.Action != "update" || local.Pending.Binding.Version != "1.0.0" || local.Pending.Intent != cfg.intent["demo"].Bindings["claude"].fingerprint() {
|
|
t.Fatal("fixture lacks a pending owned Claude update at 1.0.0")
|
|
}
|
|
if len(cfg.state.Bindings["demo"]) != 1 {
|
|
t.Fatal("fixture includes a foreign target receipt")
|
|
}
|
|
|
|
return s, agents
|
|
}
|
|
|
|
func loadBinding(t *testing.T, s *Service) Binding {
|
|
t.Helper()
|
|
cfg, err := s.load()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return cfg.packages["demo"].Bindings["claude"]
|
|
}
|
|
|
|
// An imported plugin updates to whatever its native marketplace now holds, and records it.
|
|
func TestClaudeUpdateOfAnImportRecordsTheVersionItInstalled(t *testing.T) {
|
|
s, _ := importedDemo(t)
|
|
applyPluginRequest(t, s, Request{Action: "update", Name: "demo", Targets: []string{"claude"}})
|
|
if b := loadBinding(t, s); b.Version != "2.0.0" || b.Pending != "" {
|
|
t.Fatalf("binding: %+v", b)
|
|
}
|
|
}
|
|
|
|
// The dashboard's batch update takes the same path for an import.
|
|
func TestBatchUpdateOfAnImportRecordsTheVersionItInstalled(t *testing.T) {
|
|
s, _ := importedDemo(t)
|
|
unlock, err := s.Lock()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
defer unlock()
|
|
check, err := s.Preview(context.Background(), Request{Action: "check", Name: "demo"})
|
|
if err != nil || len(check.Changes) != 1 {
|
|
t.Fatalf("check: %+v %v", check, err)
|
|
}
|
|
if _, err := updateDemo(s, map[string]Seen{"claude": checkedObservation(t, check.Changes[0].Binding)}); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if b := loadBinding(t, s); b.Version != "2.0.0" || b.Pending != "" {
|
|
t.Fatalf("binding: %+v", b)
|
|
}
|
|
}
|
|
|
|
// Importing again records the version the native client has now, not the one first imported.
|
|
func TestImportAgainRecordsTheInstalledVersion(t *testing.T) {
|
|
agents := &fakeAgents{installed: map[string][]Installed{"claude": {{ID: "demo@team", PluginID: "demo@team", Installed: true, Enabled: true, Version: "1.0.0", Scope: "user"}}}, markets: map[string]map[string]string{"claude": {"team": "/team"}}}
|
|
s := agents.service(t)
|
|
applyPluginRequest(t, s, Request{Action: "import", From: "claude", Plugin: "demo@team"})
|
|
agents.installed["claude"][0].Version = "2.0.0"
|
|
applyPluginRequest(t, s, Request{Action: "import", From: "claude", Plugin: "demo@team"})
|
|
if cfg, _ := s.load(); cfg.packages["demo"].Bindings["claude"].Version != "2.0.0" {
|
|
t.Fatalf("binding: %+v", cfg.packages["demo"].Bindings["claude"])
|
|
}
|
|
}
|
|
|
|
// A binding added from a source keeps the version Skillshare reviewed when imported again.
|
|
func TestImportAgainKeepsTheReviewedVersion(t *testing.T) {
|
|
agents := &fakeAgents{version: "1.0.0"}
|
|
s := agents.service(t)
|
|
applyPluginRequest(t, s, Request{Action: "add", Source: fixture(t), Targets: []string{"claude"}})
|
|
agents.installed["claude"][0].Version = "native-1"
|
|
applyPluginRequest(t, s, Request{Action: "import", From: "claude", Plugin: agents.installed["claude"][0].ID, Name: "demo"})
|
|
if b := loadBinding(t, s); b.Version != "1.0.0" {
|
|
t.Fatalf("binding: %+v", b)
|
|
}
|
|
}
|
|
|
|
// A skipped update stays pending, so a later sync still knows the plugin is behind.
|
|
func TestSkippedUpdateStaysPending(t *testing.T) {
|
|
agents := &fakeAgents{version: "1.0.0"}
|
|
s := agents.service(t)
|
|
source := fixture(t)
|
|
applyPluginRequest(t, s, Request{Action: "add", Source: source, Targets: []string{"codex"}})
|
|
cfg, err := s.load()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
pack := cfg.packages["demo"]
|
|
b := pack.Bindings["codex"]
|
|
b.Pending = "update"
|
|
pack.Bindings["codex"] = b
|
|
cfg.packages["demo"] = pack
|
|
local := cfg.state.Bindings["demo"]["codex"]
|
|
local.Pending = &receipt{Intent: cfg.intent["demo"].Bindings["codex"].fingerprint(), Store: s.storeIdentity("codex"), Binding: b, Action: "update"}
|
|
cfg.putLocal("demo", "codex", local)
|
|
if err := s.saveState(cfg); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
agents.installed["codex"][0].Enabled = false
|
|
applyPluginRequest(t, s, Request{Action: "sync"})
|
|
if cfg, _ = s.load(); cfg.packages["demo"].Bindings["codex"].Pending != "update" {
|
|
t.Fatalf("pending cleared: %+v", cfg.packages["demo"].Bindings["codex"])
|
|
}
|
|
}
|
|
|
|
func TestCanonicalSourceExpandsBareTilde(t *testing.T) {
|
|
home := t.TempDir()
|
|
t.Setenv("HOME", home)
|
|
if got := canonicalSource("~"); got != home {
|
|
t.Fatalf("canonicalSource(~) = %q, want %q", got, home)
|
|
}
|
|
}
|
|
|
|
func TestSavingPluginsCreatesTheTargetOfADanglingSymlink(t *testing.T) {
|
|
agents := &fakeAgents{version: "1.0.0"}
|
|
s := agents.service(t)
|
|
shared := filepath.Join(os.Getenv("HOME"), "dotfiles", "skillshare.yaml")
|
|
if err := os.Symlink(shared, s.ConfigPath); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
applyPluginRequest(t, s, Request{Action: "add", Source: fixture(t), Targets: []string{"claude"}})
|
|
if info, err := os.Lstat(s.ConfigPath); err != nil || info.Mode()&os.ModeSymlink == 0 {
|
|
t.Fatalf("config.yaml is no longer a symlink: %v", err)
|
|
}
|
|
if data, err := os.ReadFile(shared); err != nil || !strings.Contains(string(data), "plugins:") {
|
|
t.Fatalf("symlink target not written: %v\n%s", err, data)
|
|
}
|
|
}
|
|
|
|
// bumpedDemo is demo added at 1.0.0 whose source now offers 2.0.0, under the lock a batch holds.
|
|
func bumpedDemo(t *testing.T) (*Service, *fakeAgents) {
|
|
t.Helper()
|
|
agents := &fakeAgents{version: "1.0.0"}
|
|
s := agents.service(t)
|
|
source := fixture(t)
|
|
applyPluginRequest(t, s, Request{Action: "add", Source: source, Targets: []string{"claude"}})
|
|
bumpDemo(t, source, agents)
|
|
unlock, err := s.Lock()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
t.Cleanup(unlock)
|
|
return s, agents
|
|
}
|
|
|
|
// checkedObservation crosses the same JSON boundary as the dashboard's observed binding.
|
|
func checkedObservation(t *testing.T, binding Binding) Seen {
|
|
t.Helper()
|
|
raw, err := json.Marshal(binding)
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
var observed Seen
|
|
if err := json.Unmarshal(raw, &observed); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
return observed
|
|
}
|
|
|
|
func updateDemo(s *Service, seen map[string]Seen) (*Result, error) {
|
|
_, result, err := s.updateLocked(context.Background(), UpdateItem{Name: "demo", Targets: []string{"claude"}, Seen: seen}, func(*Plan) {})
|
|
return result, err
|
|
}
|
|
|
|
// Batch updates may install only the source the user approved, including a missing native installation.
|
|
func TestBatchUpdateUsesOnlyTheSourceTheCheckShowed(t *testing.T) {
|
|
for _, scenario := range []string{"version moved", "content moved", "no approval", "missing identity", "matching approval"} {
|
|
for _, missing := range []bool{false, true} {
|
|
t.Run(scenario+"/"+map[bool]string{false: "present", true: "removed"}[missing], func(t *testing.T) {
|
|
s, agents := bumpedDemo(t)
|
|
checked, err := s.Preview(context.Background(), Request{Action: "check", Name: "demo"})
|
|
if err != nil || len(checked.Changes) != 1 || checked.Changes[0].Action != "update-available" {
|
|
t.Fatalf("check: %+v %v", checked, err)
|
|
}
|
|
binding := checked.Changes[0].Binding
|
|
seen := map[string]Seen{"claude": checkedObservation(t, binding)}
|
|
switch scenario {
|
|
case "version moved":
|
|
moved := seen["claude"]
|
|
moved.Version = "1.5.0"
|
|
seen["claude"] = moved
|
|
case "content moved":
|
|
writeFile(t, binding.Source, "skills/demo/SKILL.md", "source changed after approval")
|
|
case "no approval":
|
|
seen = nil
|
|
case "missing identity":
|
|
seen["claude"] = Seen{Version: binding.Version, Commit: binding.Commit, Digest: binding.Digest}
|
|
}
|
|
if missing {
|
|
agents.installed["claude"] = nil
|
|
}
|
|
same := unchanged(t, s.ConfigPath, s.statePath())
|
|
result, err := updateDemo(s, seen)
|
|
if scenario != "matching approval" {
|
|
if err != ErrSourceMoved || len(agents.commands) != 0 {
|
|
t.Fatalf("unapproved source: %v, commands %q", err, agents.commands)
|
|
}
|
|
same()
|
|
return
|
|
}
|
|
if err != nil || len(result.Results) != 1 || result.Results[0].Status != "installed" {
|
|
t.Fatalf("approved update: %+v %v", result, err)
|
|
}
|
|
installed := readState(t, s).packages["demo"].Bindings["claude"]
|
|
if installed.Digest != binding.Digest || installed.Version != binding.Version || !s.ownedSnapshot(installed, "claude") {
|
|
t.Fatalf("update lost approved source: %+v", installed)
|
|
}
|
|
})
|
|
}
|
|
}
|
|
}
|
|
|
|
// A stop lets the plugin under way finish, starts no other, and a failed one still counts.
|
|
func TestBatchUpdateStartsNoPluginAfterAStop(t *testing.T) {
|
|
s, _ := bumpedDemo(t)
|
|
var started, ended []string
|
|
failed := s.UpdateBatch(context.Background(), Batch{
|
|
Items: []UpdateItem{{Name: "missing", Targets: []string{"claude"}}, {Name: "demo", Targets: []string{"claude"}}},
|
|
Stopped: func() bool { return len(started) > 0 },
|
|
Around: func(update func()) { update() },
|
|
Started: func(name string) { started = append(started, name) },
|
|
Planned: func(string, *Plan) {},
|
|
Ended: func(name string, _ *Plan, _ *Result, _ error) { ended = append(ended, name) },
|
|
})
|
|
if failed != 1 || !slices.Equal(ended, []string{"missing"}) {
|
|
t.Fatalf("failed %d, ended %q", failed, ended)
|
|
}
|
|
}
|
|
|
|
func TestPluginUpdateAllValidationAndPartialFailureIsolation(t *testing.T) {
|
|
agents := &fakeAgents{version: "1.0.0"}
|
|
s := agents.service(t)
|
|
sourceA := fixture(t)
|
|
sourceB := t.TempDir()
|
|
writeFile(t, sourceB, ".claude-plugin/plugin.json", `{"name":"other","version":"1.0.0","skills":"./skills"}`)
|
|
writeFile(t, sourceB, "skills/other/SKILL.md", "---\nname: other\n---\nother")
|
|
|
|
applyPluginRequest(t, s, Request{Action: "add", Source: sourceA, Targets: []string{"claude", "omp"}})
|
|
applyPluginRequest(t, s, Request{Action: "add", Source: sourceB, Targets: []string{"claude"}})
|
|
|
|
for _, bad := range []Request{
|
|
{Action: "update"},
|
|
{Action: "update", Name: "demo", All: true},
|
|
{Action: "update", SourceRef: "main", All: true},
|
|
{Action: "sync", All: true},
|
|
} {
|
|
if _, err := s.Preview(context.Background(), bad); err == nil {
|
|
t.Fatalf("expected validation error for %+v", bad)
|
|
}
|
|
}
|
|
|
|
// OMP inventory is present, but this fake has no native registry proving ownership.
|
|
// The batch must report that failure while updating both healthy Claude bindings.
|
|
oldOMP := readState(t, s).packages["demo"].Bindings["omp"]
|
|
bumpDemo(t, sourceA, agents)
|
|
writeFile(t, sourceB, ".claude-plugin/plugin.json", `{"name":"other","version":"2.0.0","skills":"./skills"}`)
|
|
writeFile(t, sourceB, "skills/other/SKILL.md", "---\nname: other\n---\nother v2")
|
|
same := unchanged(t, s.ConfigPath)
|
|
req := Request{Action: "update", All: true}
|
|
plan, err := s.Preview(context.Background(), req)
|
|
if err != nil || plan.Blocked || !slices.ContainsFunc(plan.Changes, func(c Change) bool {
|
|
return c.Name == "demo" && c.Target == "omp" && c.Failed && strings.Contains(c.Message, "inventory and native registration disagree")
|
|
}) {
|
|
t.Fatalf("batch preview did not isolate the unverifiable OMP target: %+v %v", plan, err)
|
|
}
|
|
result, err := s.Apply(context.Background(), req, plan.Revision)
|
|
if err == nil || !strings.Contains(err.Error(), "inventory and native registration disagree") || result == nil || len(result.Results) != 3 {
|
|
t.Fatalf("batch did not report the OMP failure: %+v %v", result, err)
|
|
}
|
|
for _, want := range []struct{ name, target, status string }{{"demo", "claude", "installed"}, {"demo", "omp", "failed"}, {"other", "claude", "installed"}} {
|
|
if !slices.ContainsFunc(result.Results, func(o Outcome) bool {
|
|
return o.Name == want.name && o.Target == want.target && o.Status == want.status && (want.status != "failed" || strings.Contains(o.Message, "inventory and native registration disagree"))
|
|
}) {
|
|
t.Fatalf("batch outcome missing %+v: %+v", want, result.Results)
|
|
}
|
|
}
|
|
same()
|
|
cfg, err := s.load()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if cfg.packages["demo"].Bindings["claude"].Version != "2.0.0" || cfg.packages["other"].Bindings["claude"].Version != "2.0.0" {
|
|
t.Fatalf("update --all did not update all packages: %+v", cfg.packages)
|
|
}
|
|
|
|
if got := cfg.packages["demo"].Bindings["omp"]; got.ID != oldOMP.ID || got.Version != oldOMP.Version || got.Digest != oldOMP.Digest {
|
|
t.Fatalf("failed OMP binding changed: before=%+v after=%+v", oldOMP, got)
|
|
}
|
|
|
|
// Remove sourceA on disk so its discovery fails, while bumping sourceB to 3.0.0.
|
|
if err := os.RemoveAll(sourceA); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
writeFile(t, sourceB, ".claude-plugin/plugin.json", `{"name":"other","version":"3.0.0","skills":"./skills"}`)
|
|
writeFile(t, sourceB, "skills/other/SKILL.md", "---\nname: other\n---\nother v3")
|
|
|
|
agents.version = "3.0.0"
|
|
var applyErr error
|
|
_ = s.WithDiscoveryCache(func() error {
|
|
req := Request{Action: "update", All: true}
|
|
p, pErr := s.Preview(context.Background(), req)
|
|
if pErr != nil {
|
|
t.Fatalf("preview --all should isolate source error, got: %v", pErr)
|
|
}
|
|
if p.Blocked {
|
|
t.Fatalf("preview --all should not be blocked by one broken source: %+v", p.Changes)
|
|
}
|
|
result, applyErr = s.Apply(context.Background(), req, p.Revision)
|
|
return nil
|
|
})
|
|
if applyErr == nil {
|
|
t.Fatalf("expected partial failure error from Apply when a source failed discovery, got nil (result=%+v)", result)
|
|
}
|
|
same()
|
|
cfg, err = s.load()
|
|
if err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
if cfg.packages["other"].Bindings["claude"].Version != "3.0.0" {
|
|
t.Fatalf("healthy package was not updated during partial failure: %+v", cfg.packages["other"])
|
|
}
|
|
if cfg.packages["demo"].Bindings["claude"].Version != "2.0.0" || cfg.packages["demo"].Bindings["claude"].Pending != "" {
|
|
t.Fatalf("failed package binding should remain untouched at 2.0.0: %+v", cfg.packages["demo"])
|
|
}
|
|
}
|
|
|
|
func TestPluginUpdateAllOnSharedHostIsolatesMissingSource(t *testing.T) {
|
|
for _, existing := range []bool{false, true} {
|
|
t.Run(map[bool]string{false: "fresh", true: "replacement"}[existing], func(t *testing.T) {
|
|
var aCalls, bCalls []string
|
|
a := fakePiNpm(t, &aCalls)
|
|
broken, healthy := hostStatePiSource(t), t.TempDir()
|
|
writeFile(t, healthy, "package.json", `{"name":"other","version":"1.0.0","keywords":["pi-package"]}`)
|
|
writeFile(t, healthy, "extensions/other.ts", "export default () => {}")
|
|
applyPluginRequest(t, a, Request{Action: "add", Source: broken, Targets: []string{"pi"}})
|
|
applyPluginRequest(t, a, Request{Action: "add", Source: healthy, Targets: []string{"pi"}})
|
|
shared, _ := os.ReadFile(a.ConfigPath)
|
|
b := fakePiNpm(t, &bCalls)
|
|
writePluginFile(t, filepath.Dir(b.ConfigPath), filepath.Base(b.ConfigPath), string(shared))
|
|
oldID := ""
|
|
if existing {
|
|
applyPluginRequest(t, b, Request{Action: "sync"})
|
|
oldID = readState(t, b).state.Bindings["demo"]["pi"].Applied.Binding.ID
|
|
repairHost(t, a)
|
|
applyPluginRequest(t, a, Request{Action: "remove", Name: "demo", Targets: []string{"pi"}})
|
|
broken = hostStatePiSource(t)
|
|
applyPluginRequest(t, a, Request{Action: "add", Name: "demo", Source: broken, Targets: []string{"pi"}})
|
|
shared, _ = os.ReadFile(a.ConfigPath)
|
|
writePluginFile(t, filepath.Dir(b.ConfigPath), filepath.Base(b.ConfigPath), string(shared))
|
|
repairHost(t, b)
|
|
}
|
|
writeFile(t, healthy, "package.json", `{"name":"other","version":"2.0.0","keywords":["pi-package"]}`)
|
|
if err := os.RemoveAll(broken); err != nil {
|
|
t.Fatal(err)
|
|
}
|
|
same := unchanged(t, b.ConfigPath)
|
|
_ = b.WithDiscoveryCache(func() error {
|
|
request := Request{Action: "update", All: true}
|
|
plan, err := b.Preview(context.Background(), request)
|
|
if err != nil || plan.Blocked {
|
|
t.Fatalf("shared host --all did not isolate missing source: %+v %v", plan, err)
|
|
}
|
|
result, err := b.Apply(context.Background(), request, plan.Revision)
|
|
if err == nil || result == nil {
|
|
t.Fatalf("missing source did not report partial failure: %+v %v", result, err)
|
|
}
|
|
return nil
|
|
})
|
|
d := readState(t, b)
|
|
if d.packages["other"].Bindings["pi"].ID == "" || d.packages["other"].Bindings["pi"].Version != "2.0.0" {
|
|
t.Fatalf("shared host --all skipped healthy source: %+v", d.packages)
|
|
}
|
|
local := d.state.Bindings["demo"]["pi"]
|
|
if existing {
|
|
if local.Applied == nil || local.Applied.Binding.ID != oldID || local.Pending != nil || !slices.ContainsFunc(b.host(context.Background(), "pi").Installed, func(i Installed) bool { return i.ID == oldID }) {
|
|
t.Fatalf("failed replacement changed the previous native installation: %+v", local)
|
|
}
|
|
} else if len(d.state.Bindings["demo"]) != 0 {
|
|
t.Fatalf("missing source acquired a receipt: %+v", local)
|
|
}
|
|
same()
|
|
})
|
|
}
|
|
}
|