Files
skillshare/internal/plugin/omp_remove.go
T
Willie 4556438575 fix(plugin): let OMP and Pi plugin updates through without uninstalling (#833) (#837)
* fix(plugin): let OMP and Pi plugin updates through without uninstalling (#833)

Every OMP update was blocked, because OMP's native upgrade replaces cache
folders that projects outside its inventory may still use. The only way to
move an OMP binding to a new commit was to uninstall first. An update now
runs the same pair a source change already uses: the scoped removal
adapter (cache kept), then an install under a fresh marketplace and cache
identity. A refresh always takes a new identity, because OMP installs from
the catalog it cached when the marketplace was added, and that catalog
still names the old version. If the removal cannot be verified, the
update is blocked; update --all still skips it with the reason.

Pi was blocked whenever the catalog plugin name differed from its
package.json name. That happens after an upstream npm rename, for example
when npm refused the original name. Pi installs by path, and Skillshare
keys the binding by the catalog name, so the npm name never reaches
either, and the check only stopped working installs.

Updating one package across several Agents stopped every Agent as soon as
one was blocked. Each failing Agent is now reported with its reason while
the others update, and the command exits non-zero. A single --target, or
a package with no other Agent to update, stays blocked as before, so a
dry-run still fails when nothing would update.

* fix(plugin): let one update --all refresh several OMP packages

Every OMP removal proves itself against a fingerprint of the whole native
registry and lock. In a single update --all plan, the first package's
removal and reinstall rewrite those shared files. The second package's
removal therefore saw "OMP native files changed", so only one OMP
package could update per run. The same applied to a sync that replaced
the sources of several OMP packages.

A removal now also fingerprints only its own installation: its registry
entry, its lock entry, its package manifest and its runtime link. After
an earlier change in the same apply has written to that OMP target, the
removal re-reads the files and runs every ownership check again. It goes
ahead only if that own fingerprint still matches the preview. A change
outside Skillshare to the package's own entries still blocks it. Without
an earlier write in the apply, the full-file check is unchanged.

The fake OMP in the tests now merges installs into the registry and lock
and lists them in a stable order, as the real one keeps other plugins.
2026-11-10 21:46:42 +08:00

389 lines
13 KiB
Go

package plugin
import (
"bytes"
"encoding/json"
"fmt"
"os"
"path/filepath"
"regexp"
"slices"
"strings"
"skillshare/internal/utils"
)
// OMP's native uninstall deletes shared cache. This adapter removes only the
// selected scope's registration, runtime selection and verified link. Cache,
// marketplaces and plugin settings stay intact, including on partial retries.
type ompRemoval struct {
root, id, version, cacheRoot, link, target, revision string
// subject fingerprints only this installation's own entries, manifest and link.
subject string
files []*ompRemovalFile
linkPresent bool
// rebase lets apply accept native files that an earlier change in the same
// apply rewrote, as long as this installation's own state is unchanged.
rebase bool
}
type ompRemovalFile struct {
path string
raw, after []byte
mode os.FileMode
body map[string]json.RawMessage
}
var ompRuntimeName = regexp.MustCompile(`^(?:@[a-zA-Z0-9][a-zA-Z0-9._~-]*/)?[a-zA-Z0-9][a-zA-Z0-9._~-]*$`)
func ompRemovalJSON(path string) (*ompRemovalFile, error) {
if err := ompSafePath(path); err != nil {
return nil, err
}
f := &ompRemovalFile{path: path, body: map[string]json.RawMessage{}}
info, err := os.Lstat(path)
if os.IsNotExist(err) {
return f, nil
}
if err != nil || !info.Mode().IsRegular() {
return nil, fmt.Errorf("OMP metadata is not a readable regular file")
}
f.mode = info.Mode().Perm()
f.raw, err = os.ReadFile(path)
if err != nil {
return nil, err
}
if !json.Valid(f.raw) || !piLossless(f.raw) || jsonDuplicateKeys(f.raw) || json.Unmarshal(f.raw, &f.body) != nil || f.body == nil {
return nil, fmt.Errorf("OMP metadata must be an unambiguous JSON object")
}
return f, nil
}
func ompRemovalObject(f *ompRemovalFile, key string) (map[string]json.RawMessage, error) {
m := map[string]json.RawMessage{}
if raw, ok := f.body[key]; ok && (json.Unmarshal(raw, &m) != nil || m == nil) {
return nil, fmt.Errorf("invalid OMP %s map", key)
}
return m, nil
}
func ompRemovalPrune(f *ompRemovalFile, key, name string) error {
m, err := ompRemovalObject(f, key)
if err != nil {
return err
}
if _, exists := m[name]; !exists {
return nil
}
delete(m, name)
f.body[key], err = json.Marshal(m)
if err != nil {
return err
}
f.after, err = json.MarshalIndent(f.body, "", " ")
f.after = append(f.after, '\n')
return err
}
func ompRemovalPackage(cache, fallback string) (string, *ompRemovalFile, error) {
pkg, err := ompRemovalJSON(filepath.Join(cache, "package.json"))
if err != nil {
return "", nil, err
}
name := fallback
if raw, ok := pkg.body["name"]; ok && (json.Unmarshal(raw, &name) != nil || name == "") {
return "", nil, fmt.Errorf("invalid OMP runtime package name")
}
if len(name) > 214 || !ompRuntimeName.MatchString(name) {
return "", nil, fmt.Errorf("unsafe OMP runtime package name")
}
return name, pkg, nil
}
func (s *Service) ompRemovalPlan(b Binding, cacheRoot string) (*ompRemoval, error) {
if b.Version == "" {
b.Version = "0.0.0"
}
name, market, ok := strings.Cut(b.ID, "@")
if !ok || !validOMPName(name) || !validOMPName(market) || b.Version == "" || filepath.Base(b.Version) != b.Version || strings.ContainsAny(b.Version, "\\/\r\n\x00") || cacheRoot == "" {
return nil, fmt.Errorf("OMP installation identity cannot be verified")
}
root := filepath.Dir(filepath.Dir(cacheRoot))
scope := "user"
if s.ProjectRoot != "" {
root = filepath.Join(s.ProjectRoot, ".omp", "plugins")
scope = "project"
}
p := &ompRemoval{root: root, id: b.ID, version: b.Version, cacheRoot: cacheRoot}
reg, err := ompRemovalJSON(filepath.Join(root, "installed_plugins.json"))
if err != nil {
return nil, err
}
if len(reg.raw) != 0 && string(reg.body["version"]) != "2" {
return nil, fmt.Errorf("unsupported OMP installed registry version")
}
plugins, err := ompRemovalObject(reg, "plugins")
if err != nil {
return nil, err
}
cache := ompCachePath(cacheRoot, b.ID, b.Version)
// Even when native registration is already absent, the retained cache proves
// which runtime key/link a partially completed removal still owns.
module, pkg, err := ompRemovalPackage(cache, name)
if err != nil {
return nil, err
}
p.files = append(p.files, reg, pkg)
cfg, err := ompRemovalJSON(filepath.Join(root, "omp-plugins.lock.json"))
if err != nil {
return nil, err
}
runtimePlugins, err := ompRemovalObject(cfg, "plugins")
if err != nil {
return nil, err
}
// A missing manifest cannot prove the runtime name. Recover it only from
// one lock key whose scope-local link targets this exact retained cache.
matched := false
runtimeNames := map[string]string{}
for key := range runtimePlugins {
if len(key) > 214 || !ompRuntimeName.MatchString(key) {
return nil, fmt.Errorf("unsafe OMP runtime package name")
}
link := filepath.Join(root, "node_modules", filepath.FromSlash(key))
if err := ompSafePath(filepath.Dir(link)); err != nil {
return nil, err
}
target, err := os.Readlink(link)
if err != nil {
continue
}
if !filepath.IsAbs(target) {
target = filepath.Join(filepath.Dir(link), target)
}
target = filepath.Clean(target)
if _, exists := runtimeNames[target]; exists {
runtimeNames[target] = ""
} else {
runtimeNames[target] = key
}
if target != cache {
continue
}
if matched || pkg.body["name"] != nil && module != key {
return nil, fmt.Errorf("OMP runtime ownership is ambiguous")
}
module, matched = key, true
}
if pkg.body["name"] == nil && !matched {
_, registered := plugins[b.ID]
_, selected := runtimePlugins[module]
_, cacheErr := os.Lstat(cache)
if !registered && !selected && os.IsNotExist(cacheErr) {
// Native uninstall already removed this installation. Forget only the
// Skillshare binding; another plugin's node_modules is not our state.
p.files = append(p.files, cfg)
return p, nil
}
_, err := os.Lstat(filepath.Join(root, "node_modules"))
if registered || !os.IsNotExist(err) {
return nil, fmt.Errorf("OMP runtime name cannot be verified without its manifest or link")
}
}
for id, raw := range plugins {
var entries []struct{ Scope, InstallPath, Version string }
if json.Unmarshal(raw, &entries) != nil || len(entries) != 1 {
return nil, fmt.Errorf("ambiguous OMP installed entries")
}
e := entries[0]
if id == b.ID {
if e.Scope != scope || filepath.Clean(e.InstallPath) != cache || e.Version != b.Version {
return nil, fmt.Errorf("OMP installation changed; import its current version before removing")
}
continue
}
other, _, valid := strings.Cut(id, "@")
if !valid || !filepath.IsAbs(e.InstallPath) || ompSafePath(e.InstallPath) != nil {
return nil, fmt.Errorf("another OMP runtime owner cannot be verified")
}
otherName, otherPkg, err := ompRemovalPackage(e.InstallPath, other)
if err != nil {
return nil, err
}
p.files = append(p.files, otherPkg)
if otherPkg.body["name"] == nil {
otherName = runtimeNames[filepath.Clean(e.InstallPath)]
if otherName == "" {
return nil, fmt.Errorf("another OMP runtime owner cannot be verified")
}
}
if strings.EqualFold(module, otherName) {
return nil, fmt.Errorf("OMP runtime package has another owner")
}
}
manifest, err := ompRemovalJSON(filepath.Join(root, "package.json"))
if err != nil {
return nil, err
}
deps, err := ompRemovalObject(manifest, "dependencies")
if err != nil {
return nil, err
}
for dep := range deps {
if strings.EqualFold(dep, module) {
return nil, fmt.Errorf("OMP runtime package is also an npm dependency")
}
}
p.files = append(p.files, cfg, manifest)
own := [][]byte{plugins[b.ID], runtimePlugins[module], pkg.raw, []byte(module)}
if err := ompRemovalPrune(reg, "plugins", b.ID); err != nil {
return nil, err
}
if err := ompRemovalPrune(cfg, "plugins", module); err != nil {
return nil, err
}
p.link = filepath.Join(root, "node_modules", filepath.FromSlash(module))
if err := ompSafePath(filepath.Dir(p.link)); err != nil {
return nil, err
}
info, err := os.Lstat(p.link)
if err == nil {
if !utils.IsLinkMode(p.link, info.Mode()) {
return nil, fmt.Errorf("OMP runtime path is not a link; preserve its files before removing")
}
p.target, err = os.Readlink(p.link)
if err != nil {
return nil, err
}
resolved := p.target
if !filepath.IsAbs(resolved) {
resolved = filepath.Join(filepath.Dir(p.link), resolved)
}
if filepath.Clean(resolved) != cache {
return nil, fmt.Errorf("OMP runtime link belongs to another installation")
}
p.linkPresent = true
} else if !os.IsNotExist(err) {
return nil, err
}
var fingerprint bytes.Buffer
for _, f := range p.files {
fmt.Fprintf(&fingerprint, "%s\x00%o", f.path, f.mode)
fingerprint.WriteByte(0)
fingerprint.Write(f.raw)
fingerprint.WriteByte(0)
}
fmt.Fprintf(&fingerprint, "%s\x00%s\x00%t", p.link, p.target, p.linkPresent)
p.revision = hash(fingerprint.Bytes())
p.subject = hash(append(bytes.Join(own, []byte{0}), fmt.Sprintf("\x00%s\x00%s\x00%t", p.link, p.target, p.linkPresent)...))
return p, nil
}
func (s *Service) prepareOMPRemoval(h Host, c *Change) {
if !ompVerified(h.Version) || h.ompCacheRoot == "" {
c.Action = "blocked"
c.Message = "OMP removal requires a verified version (" + ompVerifiedRange + ") and a verified native root."
} else {
p, err := s.ompRemovalPlan(c.Binding, h.ompCacheRoot)
if err != nil {
c.Action = "blocked"
c.Message = "Cannot safely remove this OMP installation: " + err.Error()
} else if len(p.files[0].after) == 0 && slices.ContainsFunc(h.Installed, func(i Installed) bool { return i.ID == c.ID }) {
c.Action, c.Message = "blocked", "OMP inventory and native registration disagree; preview again."
} else {
for _, f := range p.files {
if len(f.after) == 0 {
continue
}
// The existing private-state ACL check prevents temporary copies of
// native settings becoming public on Windows. Never repair ACLs here.
if err := checkPiRegistrationPrivate(filepath.Dir(f.path)); err != nil {
c.Action, c.Message, c.MessageKey = "blocked", err.Error(), "plugins.error.ompRemovalSafety"
return
}
if err := checkPiRegistrationPrivate(f.path); err != nil {
c.Action, c.Message, c.MessageKey = "blocked", err.Error(), "plugins.error.ompRemovalSafety"
return
}
}
changed := p.linkPresent || len(p.files[0].after) != 0 || len(p.files[len(p.files)-2].after) != 0
if changed {
c.ompRemoval = p
if c.Action == "forget" {
c.Action = "remove"
}
} else if c.Action == "uninstall" {
c.Action = "noop"
c.Message, c.MessageKey = "", ""
return
}
c.Message, c.MessageKey = "Removes this scope's registration and runtime link. Shared cache, marketplaces and plugin settings are retained for other projects and later reinstalls.", "plugins.note.ompRemoval"
return
}
}
c.MessageKey, c.MessageArgs = "plugins.error.ompRemovalSafety", nil
}
func (s *Service) applyOMPRemoval(p *ompRemoval) error {
// ponytail: native plugin writers do not take this lock; revisions catch observed
// edits, not an atomic native CAS. Concurrent native management needs an upstream transaction.
release, err := ompAcquireLock(filepath.Join(p.root, "installed_plugins.json"))
if err != nil {
return err
}
defer release()
current, err := s.ompRemovalPlan(Binding{ID: p.id, Version: p.version}, p.cacheRoot)
if err != nil {
return err
}
if current.revision != p.revision && !(p.rebase && current.subject == p.subject) {
return fmt.Errorf("OMP native files changed; preview removal again")
}
// Prune what the files hold now; it equals the preview unless a rebase applies.
p = current
root, err := os.OpenRoot(p.root)
if err != nil {
return err
}
defer root.Close()
// Write only pruned maps, then unlink last. Retained cache makes interruption
// recoverable from the binding's identity without copying private native settings.
for _, f := range p.files {
if len(f.after) == 0 {
continue
}
name, err := filepath.Rel(p.root, f.path)
if err != nil {
return err
}
if err := checkPiRegistrationPrivate(filepath.Dir(f.path)); err != nil {
return err
}
if err := checkPiRegistrationPrivate(f.path); err != nil {
return err
}
info, err := root.Lstat(name)
if err != nil || !info.Mode().IsRegular() {
return fmt.Errorf("OMP metadata path changed during removal")
}
before, err := root.ReadFile(name)
if err != nil || !bytes.Equal(before, f.raw) {
return fmt.Errorf("OMP native file changed during removal; preview again")
}
if err := rootAtomicWrite(root, name, f.after, f.mode, false); err != nil {
return err
}
}
if p.linkPresent {
name, err := filepath.Rel(p.root, p.link)
if err != nil {
return err
}
target, err := root.Readlink(name)
if err != nil || target != p.target {
return fmt.Errorf("OMP runtime link changed during removal; inspect it before retrying")
}
// Remove the link itself, never recurse into its target (including junctions).
if err := root.Remove(name); err != nil {
return err
}
}
return nil
}