mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-18 18:04:17 +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>
398 lines
13 KiB
Go
398 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
|
|
}
|
|
if raw, exists := plugins[b.ID]; exists {
|
|
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]
|
|
v := e.Version
|
|
if e.Scope != scope || v == "" || filepath.Base(v) != v || strings.ContainsAny(v, "\\/\r\n\x00") || !filepath.IsAbs(e.InstallPath) || filepath.Clean(e.InstallPath) != ompCachePath(cacheRoot, b.ID, v) || ompSafePath(e.InstallPath) != nil {
|
|
return nil, fmt.Errorf("OMP installation identity cannot be verified")
|
|
}
|
|
b.Version, p.version = v, v
|
|
}
|
|
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 {
|
|
if id == b.ID {
|
|
continue // This entry was validated before choosing the cache.
|
|
}
|
|
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]
|
|
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
|
|
}
|