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.. 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(ctx, 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(ctx context.Context, target string) map[string]string { result := map[string]string{} d, err := s.load() if err != nil { return result } var h *Host s.adoptLegacy(d, func(requested string) Host { if requested != target { return Host{Error: "outside requested target"} } if h == nil { current := s.host(ctx, target) h = ¤t } return *h }) for name, p := range d.packages { if b, ok := p.Bindings[target]; ok && b.ID != "" && !b.Cleanup && !b.ContextChanged { 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 } } }