mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
The Plugins page listed every binding a run touched, one row each, so a single failure sat among a dozen "unchanged" rows, and the preview did the same. Failures now come first, Agents that ended the same way share a row, and what stayed the same folds into one Unchanged line that opens to one row per plugin, with Pi packages apart. Logos stay only on the rows that need a look. An npm package in Pi recorded no version and no source, so it showed no version and Check updates could only say to check in Pi. The installed package.json now gives its version, on the Plugins page and in a Pi target's Extensions tab, and check compares that version with npm's latest. A newer version gets an Update button on the row and in the check's result; it updates that one package with pi update <source>, not pi update --extensions, which would also update packages the preview never listed. update leaves a package already at npm's latest alone, and records no version, so the dashboard keeps reading what Pi installed. The two check messages that were English in every locale now have keys. Release-As: 0.24.5
843 lines
28 KiB
Go
843 lines
28 KiB
Go
package plugin
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"io"
|
|
"maps"
|
|
"os"
|
|
"path"
|
|
"path/filepath"
|
|
"runtime"
|
|
"slices"
|
|
"strconv"
|
|
"strings"
|
|
"unicode/utf8"
|
|
)
|
|
|
|
// The extensions of a Pi target (issue #342): which package extensions its settings
|
|
// select, read statically. Global, account and project targets can change the
|
|
// selection of one extension at a time when their own Pi is PiMinVersion or later. A
|
|
// project change is saved to the project's .pi/settings.json only; whether Pi
|
|
// trusts the project, and so reads that file, stays Pi's decision.
|
|
|
|
// PiMinVersion is the oldest Pi that scripts/pi/version-matrix.sh installed and passed
|
|
// (scripts/pi/version-evidence.json): the package contract against dist/core and the
|
|
// CLI's bundle, and the native lock test. Older or unparsable versions are read-only.
|
|
const PiMinVersion = "0.99.2"
|
|
|
|
// plainVersion splits a plain X.Y.Z version into its numbers, nil for anything else.
|
|
func plainVersion(v string) []int {
|
|
fields := strings.Split(v, ".")
|
|
if len(fields) != 3 {
|
|
return nil
|
|
}
|
|
out := make([]int, 3)
|
|
for i, field := range fields {
|
|
n, err := strconv.Atoi(field)
|
|
if err != nil || n < 0 {
|
|
return nil
|
|
}
|
|
out[i] = n
|
|
}
|
|
return out
|
|
}
|
|
|
|
// piVersionSupported reports a plain X.Y.Z version at or above PiMinVersion.
|
|
func piVersionSupported(version string) bool {
|
|
got := plainVersion(version)
|
|
return got != nil && slices.Compare(got, plainVersion(PiMinVersion)) >= 0
|
|
}
|
|
|
|
// Read-only reasons, translated by the dashboard as piExtensions.readOnly.<key>.
|
|
const (
|
|
piReadOnlyFork = "fork"
|
|
piReadOnlyNoCLI = "noCli"
|
|
piReadOnlyUnsupported = "unsupportedVersion"
|
|
piReadOnlySettings = "settings"
|
|
)
|
|
|
|
type PiExtensionsView struct {
|
|
Target string `json:"target"`
|
|
Scope string `json:"scope"` // global, account or project
|
|
SettingsPath string `json:"settingsPath"`
|
|
GlobalSettingsPath string `json:"globalSettingsPath,omitempty"`
|
|
Version string `json:"version"`
|
|
MinVersion string `json:"minVersion"`
|
|
Editable bool `json:"editable"`
|
|
ReadOnly string `json:"readOnly,omitempty"`
|
|
Problem string `json:"problem,omitempty"` // the settings file cannot be used
|
|
Revision string `json:"revision"`
|
|
Packages []PiExtensionPackage `json:"packages"`
|
|
Folders []PiExtensionFolder `json:"folders"`
|
|
Trust *PiTrustHints `json:"trust,omitempty"`
|
|
}
|
|
|
|
// PiExtensionPackage is one entry of settings.json "packages". Rules is its
|
|
// "extensions" list as written, null when the entry has none.
|
|
type PiExtensionPackage struct {
|
|
Index int `json:"index"`
|
|
Source string `json:"source"`
|
|
Identity string `json:"identity"`
|
|
Kind string `json:"kind"` // npm, git, local, unknown
|
|
Form string `json:"form"` // string or object
|
|
Scope string `json:"scope"` // global or project: which file the entry is in
|
|
Shape string `json:"shape,omitempty"`
|
|
Install string `json:"install"` // present, missing or unknown
|
|
Version string `json:"version,omitempty"`
|
|
Problem string `json:"problem,omitempty"`
|
|
// ReadOnly says why rows that Skillshare can read can't be switched here:
|
|
// singleFile (Pi ignores filters) or otherResources (a first rule turns the
|
|
// string entry into an object, and Skillshare can't show that this leaves the
|
|
// package's skills, prompts and themes as they are).
|
|
ReadOnly string `json:"readOnly,omitempty"`
|
|
Rules []string `json:"rules"`
|
|
GlobalRules []string `json:"globalRules,omitempty"`
|
|
OtherKeys []string `json:"otherKeys"`
|
|
ManagedBy string `json:"managedBy,omitempty"`
|
|
Rows []PiExtensionRow `json:"rows"`
|
|
}
|
|
|
|
// PiExtensionRow is one extension. Selection is what the settings select (for a
|
|
// project: configured, if Pi trusts it); whether Pi loaded it is never known here.
|
|
type PiExtensionRow struct {
|
|
Path string `json:"path"`
|
|
File string `json:"file"` // present or missing
|
|
Selection string `json:"selection"` // loads, skipped, unknown, or none for a missing file
|
|
Origin string `json:"origin"` // default, rule, glob, emptyList, file, inherited, project, unnamed
|
|
Rule string `json:"rule,omitempty"`
|
|
Globs []string `json:"globs,omitempty"`
|
|
Editable bool `json:"editable"`
|
|
// Unruled is the row's selection once its exact rule is removed, when Skillshare
|
|
// can make that change; a switch removes the rule when that is the state it wants.
|
|
Unruled string `json:"unruled,omitempty"`
|
|
}
|
|
|
|
// PiExtensionFolder is extensions Pi finds outside packages, always read-only.
|
|
type PiExtensionFolder struct {
|
|
Path string `json:"path"`
|
|
Kind string `json:"kind"` // folder, or settings for paths listed in settings
|
|
Scope string `json:"scope,omitempty"` // project view only: global or project
|
|
Problem string `json:"problem,omitempty"`
|
|
Rows []PiExtensionFolderRow `json:"rows"`
|
|
}
|
|
|
|
type PiExtensionFolderRow struct {
|
|
Path string `json:"path"`
|
|
File string `json:"file"`
|
|
Selection string `json:"selection"`
|
|
Provenance string `json:"provenance"` // native or extras
|
|
Extra string `json:"extra,omitempty"`
|
|
}
|
|
|
|
// PiTrustHints are what Pi saved, shown as hints only: an extension handler or a
|
|
// session-only choice can decide trust differently.
|
|
type PiTrustHints struct {
|
|
Saved string `json:"saved"` // trusted, untrusted, none, unknown
|
|
Default string `json:"default"` // always, never, ask, unset, unknown
|
|
}
|
|
|
|
// piEntry is one parsed "packages" entry.
|
|
type piEntry struct {
|
|
index int
|
|
source string
|
|
object bool
|
|
fields map[string]json.RawMessage
|
|
autoloadFalse bool
|
|
rules []string
|
|
hasRules bool
|
|
problem string
|
|
// badSource: the source can't be read as Pi reads it, so the entry may be any package.
|
|
badSource bool
|
|
}
|
|
|
|
type piSettings struct {
|
|
path string
|
|
raw []byte
|
|
exists bool
|
|
problem string
|
|
body map[string]json.RawMessage
|
|
entries []piEntry
|
|
}
|
|
|
|
// readPiSettings reads settings.json as Pi does, strictly: Pi refuses JSON with
|
|
// comments, so Skillshare never treats such a file as usable.
|
|
func readPiSettings(root, file string) *piSettings {
|
|
st := &piSettings{path: file, body: map[string]json.RawMessage{}}
|
|
if err := noSymlink(root, file); err != nil {
|
|
st.problem = "symlink"
|
|
return st
|
|
}
|
|
raw, err := os.ReadFile(file)
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
return st
|
|
}
|
|
if err != nil {
|
|
st.problem = piProblemUnreadable
|
|
return st
|
|
}
|
|
st.raw, st.exists = raw, true
|
|
if len(raw) == 0 {
|
|
return st
|
|
}
|
|
switch {
|
|
case bytes.HasPrefix(raw, []byte{0xEF, 0xBB, 0xBF}):
|
|
st.problem = "bom"
|
|
case !json.Valid(raw):
|
|
st.problem = "invalidJson"
|
|
case jsonDuplicateKeys(raw):
|
|
st.problem = "duplicateKey"
|
|
case json.Unmarshal(raw, &st.body) != nil || st.body == nil:
|
|
st.problem = "notObject"
|
|
}
|
|
if st.problem != "" {
|
|
st.body = map[string]json.RawMessage{}
|
|
return st
|
|
}
|
|
var list []json.RawMessage
|
|
if field, ok := st.body["packages"]; ok && (json.Unmarshal(field, &list) != nil || list == nil) {
|
|
st.problem = "packagesInvalid"
|
|
return st
|
|
}
|
|
for i, raw := range list {
|
|
st.entries = append(st.entries, parsePiEntry(i, raw))
|
|
}
|
|
return st
|
|
}
|
|
|
|
func parsePiEntry(i int, raw json.RawMessage) piEntry {
|
|
e := piEntry{index: i}
|
|
if json.Unmarshal(raw, &e.source) == nil {
|
|
if !piSourceOK(raw, e.source) {
|
|
e.problem, e.badSource = "unsupportedEntry", true
|
|
}
|
|
return e
|
|
}
|
|
e.object = true
|
|
if json.Unmarshal(raw, &e.fields) != nil || e.fields == nil || json.Unmarshal(e.fields["source"], &e.source) != nil || !piSourceOK(e.fields["source"], e.source) {
|
|
e.problem, e.badSource = "unsupportedEntry", true
|
|
return e
|
|
}
|
|
// Native Pi uses strict === false; decoding null into bool also yields false.
|
|
if a, ok := e.fields["autoload"]; ok && bytes.Equal(bytes.TrimSpace(a), []byte("false")) {
|
|
e.autoloadFalse = true
|
|
}
|
|
if r, ok := e.fields["extensions"]; ok {
|
|
e.hasRules = true
|
|
if json.Unmarshal(r, &e.rules) != nil || e.rules == nil || !piLossless(r) {
|
|
e.rules, e.problem = nil, "unsupportedEntry"
|
|
}
|
|
}
|
|
return e
|
|
}
|
|
|
|
// piSourceOK is false for a source Pi can't use (encoding/json reads null as "")
|
|
// or one Go would not read as Pi does.
|
|
func piSourceOK(raw json.RawMessage, source string) bool {
|
|
return strings.TrimSpace(source) != "" && piLossless(raw)
|
|
}
|
|
|
|
// piLossless reports whether Go decodes the strings of a JSON value as Pi
|
|
// (JavaScript) does. Go turns an unpaired UTF-16 surrogate escape, and invalid
|
|
// UTF-8, into U+FFFD, while JavaScript keeps the surrogate, so a rule could read
|
|
// as naming a different file. raw must be valid JSON.
|
|
func piLossless(raw []byte) bool {
|
|
if !utf8.Valid(raw) {
|
|
return false
|
|
}
|
|
hex := func(i int) uint64 {
|
|
if i+4 > len(raw) {
|
|
return 0
|
|
}
|
|
n, err := strconv.ParseUint(string(raw[i:i+4]), 16, 32)
|
|
if err != nil {
|
|
return 0
|
|
}
|
|
return n
|
|
}
|
|
in := false
|
|
for i := 0; i < len(raw); i++ {
|
|
switch {
|
|
case raw[i] == '"':
|
|
in = !in
|
|
case in && raw[i] == '\\' && i+1 < len(raw) && raw[i+1] == 'u':
|
|
switch r := hex(i + 2); {
|
|
case r >= 0xD800 && r <= 0xDBFF:
|
|
if i+12 > len(raw) || raw[i+6] != '\\' || raw[i+7] != 'u' {
|
|
return false
|
|
}
|
|
if lo := hex(i + 8); lo < 0xDC00 || lo > 0xDFFF {
|
|
return false
|
|
}
|
|
i += 11
|
|
case r >= 0xDC00 && r <= 0xDFFF:
|
|
return false
|
|
default:
|
|
i += 5
|
|
}
|
|
case in && raw[i] == '\\':
|
|
i++ // the escaped character, which may be a backslash
|
|
}
|
|
}
|
|
return true
|
|
}
|
|
|
|
// otherKeys names the entry's keys besides source and extensions, never their values.
|
|
func (e piEntry) otherKeys() []string {
|
|
keys := []string{}
|
|
for k := range e.fields {
|
|
if k != "source" && k != "extensions" {
|
|
keys = append(keys, k)
|
|
}
|
|
}
|
|
slices.Sort(keys)
|
|
return keys
|
|
}
|
|
|
|
func jsonDuplicateKeys(data []byte) bool {
|
|
dec := json.NewDecoder(bytes.NewReader(data))
|
|
var walk func() bool
|
|
walk = func() bool {
|
|
tok, err := dec.Token()
|
|
if err != nil {
|
|
return false
|
|
}
|
|
switch tok {
|
|
case json.Delim('{'):
|
|
seen := map[string]bool{}
|
|
for dec.More() {
|
|
key, err := dec.Token()
|
|
if err != nil {
|
|
return false
|
|
}
|
|
k, _ := key.(string)
|
|
if seen[k] {
|
|
return true
|
|
}
|
|
seen[k] = true
|
|
if walk() {
|
|
return true
|
|
}
|
|
}
|
|
_, _ = dec.Token()
|
|
case json.Delim('['):
|
|
for dec.More() {
|
|
if walk() {
|
|
return true
|
|
}
|
|
}
|
|
_, _ = dec.Token()
|
|
}
|
|
return false
|
|
}
|
|
return walk()
|
|
}
|
|
|
|
// piPackage locates one entry's files and evaluates it against any rule list.
|
|
type piPackage struct {
|
|
src piSource
|
|
install string
|
|
version string
|
|
problem string
|
|
single bool // a local source that is one file: Pi ignores its filters
|
|
// convertLoadsOthers: a string entry can't be shown to take a rule without
|
|
// changing other resources (see piLayout.conversionLoadsOthers).
|
|
convertLoadsOthers bool
|
|
abs string // package root, slash separated, for Pi's absolute-path matching
|
|
// The file sets an evaluation draws from (see piLayout.defaults and base).
|
|
defaultsString, defaultsObject, base []string
|
|
}
|
|
|
|
func openPiPackage(source, agentDir, projectDir, scope string) *piPackage {
|
|
p := &piPackage{src: resolvePiSource(source, agentDir, projectDir, scope), install: "unknown"}
|
|
if p.src.kind == "unknown" {
|
|
p.problem = "sourceUnknown"
|
|
return p
|
|
}
|
|
info, err := os.Stat(p.src.install)
|
|
if err != nil {
|
|
if p.src.kind == "npm" && scope == "user" {
|
|
// Native Pi may fall back to a legacy global npm/pnpm root. Without
|
|
// resolving that root, absence here does not establish non-installation.
|
|
p.problem = "sourceUnknown"
|
|
return p
|
|
}
|
|
p.install, p.problem = "missing", "notInstalled"
|
|
return p
|
|
}
|
|
p.install, p.abs = "present", filepath.ToSlash(p.src.install)
|
|
if info.Mode().IsRegular() && p.src.kind == "local" {
|
|
p.single = true
|
|
return p
|
|
}
|
|
if !info.IsDir() {
|
|
p.install, p.problem = "unknown", piProblemUnreadable
|
|
return p
|
|
}
|
|
l, err := openPiLayout(p.src.install)
|
|
if err != nil {
|
|
p.problem = piProblemUnreadable
|
|
return p
|
|
}
|
|
defer l.Close()
|
|
p.defaultsString, p.defaultsObject, p.base = l.defaults(false), l.defaults(true), l.base()
|
|
p.convertLoadsOthers = l.conversionLoadsOthers()
|
|
p.problem, p.version = l.problem, l.version
|
|
return p
|
|
}
|
|
|
|
// readOnly is why an entry of this form can't be switched here, "" if it can.
|
|
func (p *piPackage) readOnly(object bool) string {
|
|
switch {
|
|
case p.single:
|
|
return "singleFile"
|
|
case p.convertLoadsOthers && !object:
|
|
return "otherResources"
|
|
}
|
|
return ""
|
|
}
|
|
|
|
type piRowState struct {
|
|
rel string
|
|
present bool
|
|
eval piEvaluation
|
|
origin string
|
|
// inherited: a project override leaves this path to the global entry.
|
|
inherited bool
|
|
}
|
|
|
|
// evaluate is the selection of an entry with this form and rule list, as Pi
|
|
// applies it in global scope.
|
|
func (p *piPackage) evaluate(object, hasRules bool, rules []string) []piRowState {
|
|
if p.single {
|
|
return []piRowState{{rel: path.Base(p.abs), present: true, eval: piEvaluation{state: piOn}, origin: "file"}}
|
|
}
|
|
rows := []piRowState{}
|
|
switch {
|
|
case !hasRules:
|
|
files := p.defaultsString
|
|
if object {
|
|
files = p.defaultsObject
|
|
}
|
|
for _, f := range files {
|
|
rows = append(rows, piRowState{rel: f, present: true, eval: piEvaluation{state: piOn}, origin: "default"})
|
|
}
|
|
case len(rules) == 0:
|
|
for _, f := range p.base {
|
|
rows = append(rows, piRowState{rel: f, present: true, eval: piEvaluation{state: piOff}, origin: "emptyList"})
|
|
}
|
|
default:
|
|
for _, f := range p.base {
|
|
e := piEvaluate(rules, f, path.Join(p.abs, f))
|
|
origin := "default"
|
|
if e.exact != "" {
|
|
origin = "rule"
|
|
} else if len(e.globs) > 0 {
|
|
origin = "glob"
|
|
}
|
|
rows = append(rows, piRowState{rel: f, present: true, eval: e, origin: origin})
|
|
}
|
|
}
|
|
// An exact rule for a file the package no longer has still sits in the list.
|
|
for _, rule := range rules {
|
|
if !strings.HasPrefix(rule, "+") && !strings.HasPrefix(rule, "-") {
|
|
continue
|
|
}
|
|
target := strings.TrimPrefix(rule[1:], "./")
|
|
if slices.ContainsFunc(rows, func(r piRowState) bool { return r.rel == target || path.Join(p.abs, r.rel) == target }) {
|
|
continue
|
|
}
|
|
rows = append(rows, piRowState{rel: target, eval: piEvaluation{state: piUnknown, exact: rule}, origin: "rule"})
|
|
}
|
|
return rows
|
|
}
|
|
|
|
func (r piRowState) row(editable bool) PiExtensionRow {
|
|
row := PiExtensionRow{Path: r.rel, File: "present", Selection: r.eval.state.String(), Origin: r.origin, Rule: r.eval.exact, Globs: r.eval.globs}
|
|
if !r.present {
|
|
row.File, row.Selection = "missing", "none"
|
|
}
|
|
// A switch needs a known state; a missing file can only lose its rule. Under []
|
|
// any added rule would change every extension of the package.
|
|
row.Editable = editable && r.origin != "emptyList" && (r.present && r.eval.state != piUnknown || !r.present && r.eval.exact != "")
|
|
return row
|
|
}
|
|
|
|
// piSetUnruled fills Unruled for each switchable row with an exact rule. try
|
|
// returns the selections after a change and whether the guard accepts it.
|
|
func piSetUnruled(rows []PiExtensionRow, try func([]PiExtensionChange) (map[string]piRowState, error)) {
|
|
for i, r := range rows {
|
|
if !r.Editable || r.File != "present" || r.Rule == "" {
|
|
continue
|
|
}
|
|
after, err := try([]PiExtensionChange{{Path: r.Path, Action: "default"}})
|
|
if a, ok := after[r.Path]; err == nil && ok && a.eval.state != piUnknown {
|
|
rows[i].Unruled = a.eval.state.String()
|
|
}
|
|
}
|
|
}
|
|
|
|
// piTryEntry is piSetUnruled's try for an entry Pi applies as written.
|
|
func piTryEntry(p *piPackage, e piEntry) func([]PiExtensionChange) (map[string]piRowState, error) {
|
|
return func(changes []PiExtensionChange) (map[string]piRowState, error) {
|
|
rules := piEditRules(e.rules, p.abs, changes)
|
|
hasRules := len(rules) > 0
|
|
return piEvaluateMap(p.evaluate(true, hasRules, rules)), piGuard(p, e, hasRules, rules, changes)
|
|
}
|
|
}
|
|
|
|
// piTryDelta is piSetUnruled's try for a project override.
|
|
func piTryDelta(rules []string, p *piPackage, inherited []piRowState, hasBase bool) func([]PiExtensionChange) (map[string]piRowState, error) {
|
|
return func(changes []PiExtensionChange) (map[string]piRowState, error) {
|
|
before := piEvaluateMap(piDeltaStates(rules, p, inherited, hasBase))
|
|
after := piEvaluateMap(piDeltaStates(piEditRules(rules, p.abs, changes), p, inherited, hasBase))
|
|
return after, piGuardStates(before, after, changes, true)
|
|
}
|
|
}
|
|
|
|
// piTargetState is everything a preview or apply of a global target needs.
|
|
type piTargetState struct {
|
|
view *PiExtensionsView
|
|
settings *piSettings
|
|
agentDir string
|
|
packages map[int]*piPackage
|
|
}
|
|
|
|
func piCLIIsNative(cli, goos string) bool {
|
|
if goos == "windows" {
|
|
// Windows paths and launcher names are case-insensitive. Only accept the
|
|
// official executable/shim names, not arbitrary or stacked suffixes.
|
|
name := strings.ToLower(path.Base(strings.ReplaceAll(cli, `\`, "/")))
|
|
return name == "pi" || name == "pi.cmd" || name == "pi.exe"
|
|
}
|
|
return filepath.Base(cli) == "pi"
|
|
}
|
|
|
|
func (s *Service) piGate(ctx context.Context, target string) (version, readOnly string) {
|
|
if a, ok := s.account(target); ok && a.CLI != "" && !piCLIIsNative(a.CLI, runtime.GOOS) {
|
|
// Known unsupported by name: never run it just to read its version.
|
|
return "", piReadOnlyFork
|
|
}
|
|
out, err := s.run(ctx, target, "--version")
|
|
version = strings.TrimSpace(string(out))
|
|
switch {
|
|
case err != nil:
|
|
return "", piReadOnlyNoCLI
|
|
case !piVersionSupported(version):
|
|
return version, piReadOnlyUnsupported
|
|
}
|
|
return version, ""
|
|
}
|
|
|
|
// PiExtensions reads the extensions of a Pi target: "pi" or a Pi account, in the
|
|
// project when ProjectRoot is set.
|
|
func (s *Service) PiExtensions(ctx context.Context, target string) (*PiExtensionsView, error) {
|
|
if s.agentOf(target) != "pi" {
|
|
return nil, errors.New("not a Pi target")
|
|
}
|
|
if s.ProjectRoot != "" {
|
|
st, err := s.piProjectState(ctx, target)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return st.view, nil
|
|
}
|
|
st, err := s.piGlobalState(ctx, target)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return st.view, nil
|
|
}
|
|
|
|
func (s *Service) piGlobalState(ctx context.Context, target string) (*piTargetState, error) {
|
|
agentDir, err := s.piAgentDir(target)
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
settings := readPiSettings(agentDir, filepath.Join(agentDir, "settings.json"))
|
|
version, readOnly := s.piGate(ctx, target)
|
|
if readOnly == "" && settings.problem != "" {
|
|
readOnly = piReadOnlySettings
|
|
}
|
|
scope := "global"
|
|
if _, ok := s.account(target); ok {
|
|
scope = "account"
|
|
}
|
|
v := &PiExtensionsView{
|
|
Target: target, Scope: scope, SettingsPath: settings.path, Version: version, MinVersion: PiMinVersion,
|
|
Editable: readOnly == "", ReadOnly: readOnly, Problem: settings.problem, Revision: hash(settings.raw),
|
|
Packages: []PiExtensionPackage{}, Folders: []PiExtensionFolder{},
|
|
}
|
|
st := &piTargetState{view: v, settings: settings, agentDir: agentDir, packages: map[int]*piPackage{}}
|
|
managed := s.piManaged(target)
|
|
seen := map[string]bool{}
|
|
unresolved := false
|
|
for _, e := range settings.entries {
|
|
pkg := PiExtensionPackage{Index: e.index, Source: redactSource(e.source), Form: "string", Scope: "global", Install: "unknown", Rules: nil, OtherKeys: e.otherKeys(), Rows: []PiExtensionRow{}}
|
|
if e.object {
|
|
pkg.Form = "object"
|
|
}
|
|
if e.hasRules {
|
|
pkg.Rules = e.rules
|
|
}
|
|
if e.problem != "" {
|
|
pkg.Problem = e.problem
|
|
// Pi still reads the entry, so it is the one that counts for its package.
|
|
if !e.badSource {
|
|
src := resolvePiSource(e.source, agentDir, "", "user")
|
|
pkg.ManagedBy = piManagedBy(managed, e.source, src)
|
|
seen[src.identity] = true
|
|
unresolved = unresolved || src.identity == ""
|
|
} else {
|
|
unresolved = true
|
|
}
|
|
v.Packages = append(v.Packages, pkg)
|
|
continue
|
|
}
|
|
p := openPiPackage(e.source, agentDir, "", "user")
|
|
st.packages[e.index] = p
|
|
pkg.Kind, pkg.Identity, pkg.Install, pkg.Version, pkg.Problem = p.src.kind, redactSource(p.src.identity), p.install, p.version, p.problem
|
|
pkg.ManagedBy = piManagedBy(managed, e.source, p.src)
|
|
switch {
|
|
case p.src.identity != "" && seen[p.src.identity]:
|
|
// Pi keeps the first entry of a package and ignores the rest.
|
|
pkg.Problem = "duplicate"
|
|
case unresolved:
|
|
// An earlier unknown identity may be the first entry of this package.
|
|
pkg.Problem = "sourceUnknown"
|
|
case e.autoloadFalse:
|
|
pkg.Problem = "autoloadGlobal"
|
|
}
|
|
unresolved = unresolved || p.src.identity == ""
|
|
seen[p.src.identity] = true
|
|
pkg.ReadOnly = p.readOnly(e.object)
|
|
if pkg.Problem == "" || pkg.Problem == "notInstalled" && len(e.rules) > 0 {
|
|
editable := v.Editable && pkg.Problem == "" && pkg.ReadOnly == ""
|
|
for _, r := range p.evaluate(e.object, e.hasRules, e.rules) {
|
|
// Rules for an uninstalled package are listed so they can be read, not changed.
|
|
if pkg.Problem != "" && r.present {
|
|
continue
|
|
}
|
|
pkg.Rows = append(pkg.Rows, r.row(editable))
|
|
}
|
|
piSetUnruled(pkg.Rows, piTryEntry(p, e))
|
|
}
|
|
v.Packages = append(v.Packages, pkg)
|
|
}
|
|
v.Folders = append(v.Folders, s.piFolders(agentDir, settings)...)
|
|
return st, nil
|
|
}
|
|
|
|
// piManaged maps the source of each plugin Skillshare installs into target to its name.
|
|
func (s *Service) piManaged(target string) map[string]string {
|
|
result := map[string]string{}
|
|
d, err := s.load()
|
|
if err != nil {
|
|
return result
|
|
}
|
|
for name, p := range d.packages {
|
|
if b, ok := p.Bindings[target]; ok && b.ID != "" {
|
|
result[b.ID] = name
|
|
}
|
|
}
|
|
return result
|
|
}
|
|
|
|
// piManagedBy is the plugin that owns a settings entry: Skillshare records a Pi
|
|
// binding by its source, or for a local package by the path it resolves to.
|
|
func piManagedBy(managed map[string]string, source string, src piSource) string {
|
|
if name := managed[strings.TrimSpace(source)]; name != "" || src.kind != "local" {
|
|
return name
|
|
}
|
|
return managed[src.install]
|
|
}
|
|
|
|
// piFolders lists the extensions Pi discovers in baseDir/extensions and the paths
|
|
// listed in the settings' own "extensions", which apply to them as overrides.
|
|
func (s *Service) piFolders(baseDir string, settings *piSettings) []PiExtensionFolder {
|
|
var top []string
|
|
if raw, ok := settings.body["extensions"]; ok && (json.Unmarshal(raw, &top) != nil || !piLossless(raw)) {
|
|
return []PiExtensionFolder{{Path: filepath.Join(baseDir, "extensions"), Kind: "folder", Problem: "unsupportedEntry", Rows: []PiExtensionFolderRow{}}}
|
|
}
|
|
overrides, plain := []string{}, []string{}
|
|
for _, r := range top {
|
|
switch {
|
|
case strings.HasPrefix(r, "+") || strings.HasPrefix(r, "-") || strings.HasPrefix(r, "!"):
|
|
overrides = append(overrides, r)
|
|
case !strings.ContainsAny(r, "*?"):
|
|
plain = append(plain, r)
|
|
}
|
|
}
|
|
selection := func(abs string, patterns []string) string {
|
|
rel, err := filepath.Rel(baseDir, abs)
|
|
if err != nil || len(patterns) == 0 {
|
|
return piOn.String()
|
|
}
|
|
return piEvaluate(patterns, filepath.ToSlash(rel), filepath.ToSlash(abs)).state.String()
|
|
}
|
|
folder := PiExtensionFolder{Path: filepath.Join(baseDir, "extensions"), Kind: "folder", Rows: []PiExtensionFolderRow{}}
|
|
if l, err := openPiLayout(baseDir); err == nil {
|
|
l.follow = true
|
|
for _, rel := range l.autoEntries("extensions") {
|
|
abs := filepath.Join(baseDir, filepath.FromSlash(rel))
|
|
row := PiExtensionFolderRow{Path: rel, File: "present", Selection: selection(abs, overrides), Provenance: "native"}
|
|
if name := s.extraOf(baseDir, rel); name != "" {
|
|
row.Provenance, row.Extra = "extras", name
|
|
}
|
|
folder.Rows = append(folder.Rows, row)
|
|
}
|
|
folder.Problem = l.problem
|
|
l.Close()
|
|
}
|
|
folders := []PiExtensionFolder{folder}
|
|
if len(plain) > 0 {
|
|
listed := PiExtensionFolder{Path: settings.path, Kind: "settings", Rows: []PiExtensionFolderRow{}}
|
|
patterns := []string{}
|
|
for _, r := range top {
|
|
if strings.HasPrefix(r, "+") || strings.HasPrefix(r, "-") || strings.HasPrefix(r, "!") || strings.ContainsAny(r, "*?") {
|
|
patterns = append(patterns, r)
|
|
}
|
|
}
|
|
for _, p := range plain {
|
|
src := resolvePiSource(p, baseDir, baseDir, "user")
|
|
row := PiExtensionFolderRow{Path: p, File: "missing", Selection: "none", Provenance: "native"}
|
|
if src.kind == "local" {
|
|
if _, err := os.Stat(src.install); err == nil {
|
|
row.File = "present"
|
|
row.Selection = selection(src.install, patterns)
|
|
if info, _ := os.Stat(src.install); info != nil && info.IsDir() {
|
|
row.Selection = piUnknown.String()
|
|
}
|
|
}
|
|
}
|
|
listed.Rows = append(listed.Rows, row)
|
|
}
|
|
folders = append(folders, listed)
|
|
}
|
|
return folders
|
|
}
|
|
|
|
// extraOf names the extra whose source a folder entry links into, "" for a native file.
|
|
func (s *Service) extraOf(baseDir, rel string) string {
|
|
first, _, _ := strings.Cut(rel, "/")
|
|
link := filepath.Join(baseDir, first)
|
|
if first == "extensions" {
|
|
next, _, _ := strings.Cut(strings.TrimPrefix(rel, "extensions/"), "/")
|
|
link = filepath.Join(baseDir, "extensions", next)
|
|
}
|
|
dest, err := os.Readlink(link)
|
|
if err != nil {
|
|
return ""
|
|
}
|
|
if !filepath.IsAbs(dest) {
|
|
dest = filepath.Join(filepath.Dir(link), dest)
|
|
}
|
|
for _, name := range slices.Sorted(maps.Keys(s.ExtrasSources)) {
|
|
if r, err := filepath.Rel(s.ExtrasSources[name], dest); err == nil && r != ".." && !strings.HasPrefix(r, ".."+string(filepath.Separator)) {
|
|
return name
|
|
}
|
|
}
|
|
return ""
|
|
}
|
|
|
|
// piDeltaStates is a project autoload:false entry: the paths its rules name are
|
|
// decided here, every other path keeps the global selection when there is one,
|
|
// and without one Pi doesn't load it at all.
|
|
func piDeltaStates(rules []string, p *piPackage, inherited []piRowState, hasBase bool) []piRowState {
|
|
rows := []piRowState{}
|
|
named := map[string]bool{}
|
|
for _, f := range p.base {
|
|
state, ok, rule := piEvaluateDelta(rules, f, path.Join(p.abs, f))
|
|
if !ok {
|
|
continue
|
|
}
|
|
named[f] = true
|
|
rows = append(rows, piRowState{rel: f, present: true, eval: piEvaluation{state: state, exact: rule}, origin: "project"})
|
|
}
|
|
// Missing exact paths still belong to the project and can lose their rules.
|
|
for _, rule := range rules {
|
|
if !strings.HasPrefix(rule, "+") && !strings.HasPrefix(rule, "-") {
|
|
continue
|
|
}
|
|
target := strings.TrimPrefix(rule[1:], "./")
|
|
if slices.ContainsFunc(rows, func(r piRowState) bool { return r.rel == target || path.Join(p.abs, r.rel) == target }) {
|
|
continue
|
|
}
|
|
named[target] = true
|
|
rows = append(rows, piRowState{rel: target, eval: piEvaluation{state: piUnknown, exact: rule}, origin: "project"})
|
|
}
|
|
if hasBase {
|
|
for _, r := range inherited {
|
|
if !named[r.rel] {
|
|
r.inherited = true
|
|
rows = append(rows, r)
|
|
}
|
|
}
|
|
return rows
|
|
}
|
|
for _, f := range p.base {
|
|
if !named[f] {
|
|
rows = append(rows, piRowState{rel: f, present: true, eval: piEvaluation{state: piOff}, origin: "unnamed"})
|
|
}
|
|
}
|
|
return rows
|
|
}
|
|
|
|
func piDeltaRows(states []piRowState, editable bool) []PiExtensionRow {
|
|
rows := []PiExtensionRow{}
|
|
for _, r := range states {
|
|
row := r.row(editable)
|
|
if r.inherited {
|
|
row.Origin = "inherited"
|
|
}
|
|
rows = append(rows, row)
|
|
}
|
|
return rows
|
|
}
|
|
|
|
// piTrust reads the decision Pi saved for root and its default, as hints.
|
|
func piTrust(agentDir, root string, global *piSettings) *PiTrustHints {
|
|
hints := &PiTrustHints{Saved: "none", Default: "unset"}
|
|
if raw, ok := global.body["defaultProjectTrust"]; ok {
|
|
var d string
|
|
hints.Default = "unknown"
|
|
if json.Unmarshal(raw, &d) == nil && slices.Contains([]string{"always", "never", "ask"}, d) {
|
|
hints.Default = d
|
|
}
|
|
}
|
|
if global.problem != "" {
|
|
hints.Default = "unknown"
|
|
}
|
|
file := filepath.Join(agentDir, "trust.json")
|
|
f, err := os.Open(file)
|
|
if errors.Is(err, os.ErrNotExist) {
|
|
return hints
|
|
}
|
|
if err != nil {
|
|
hints.Saved = "unknown"
|
|
return hints
|
|
}
|
|
defer f.Close()
|
|
data, err := io.ReadAll(io.LimitReader(f, maxPreview))
|
|
var decisions map[string]*bool
|
|
if err != nil || json.Unmarshal(trimBOM(data), &decisions) != nil {
|
|
hints.Saved = "unknown"
|
|
return hints
|
|
}
|
|
dir := root
|
|
if real, err := filepath.EvalSymlinks(root); err == nil {
|
|
dir = real
|
|
}
|
|
for dir = filepath.Clean(dir); ; dir = filepath.Dir(dir) {
|
|
if d := decisions[dir]; d != nil {
|
|
hints.Saved = map[bool]string{true: "trusted", false: "untrusted"}[*d]
|
|
return hints
|
|
}
|
|
if filepath.Dir(dir) == dir {
|
|
return hints
|
|
}
|
|
}
|
|
}
|