Files
skillshare/internal/plugin/pi_extensions.go
T
Willie ffdf9e57ab fix(plugin): stop evaluating Pi rules whose meaning depends on the Pi version (#549)
Pi 1.2.0 (earendil-works/pi#10765) runs normalizePath on resource-filter
patterns before matching, so `~`, `~/`, `file://` and, on Windows, `~\`
and Git Bash/MSYS/Cygwin/WSL drive paths now match files that older Pi
never matched. Skillshare supports Pi 0.99.2 and later without knowing
which one evaluates the rules, so it reported a definite selection that
could be wrong and let the write guard reason from it. Such rules now
evaluate as unknown, and the dashboard names the rule instead of a
generic message.

Exact rules also missed Pi's normalizeExactPattern in every version: a
leading ".\" is dropped on all platforms and backslashes become slashes
on Windows. Skillshare only dropped "./", so `-.\extensions\a.ts`
looked unmatched and produced a duplicate missing row.
2026-10-13 09:50:39 +08:00

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 := piExactPattern(rule[1:], runtime.GOOS)
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 := piExactPattern(rule[1:], runtime.GOOS)
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
}
}
}