mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
* 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.
389 lines
13 KiB
Go
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
|
|
}
|