Skip to content

Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.

2.7 KB
Raw Blame
package library

// Reading the Library page follows the links on the way to a few hundred
// paths: each agent's instructions, MCP file and skills folder, each skill
// and where it came from, CC Switch's folder, the shared skills folder,
// most of them many times over (once for each skill, or each pair of
// agents). resolve looks at a path a part at a time, so one read of the
// page looked at the same few hundred folders thousands of times, two or
// three system calls each; on Windows that alone was over a second on
// every visit (oxyuan, #1771). While a read holds the library's lock,
// what each part was found to be is kept for the rest of that read, so
// each folder is looked at once. Nothing is kept past the read: the next
// visit looks again, so a link made or changed on disk in between shows.

import (
	"errors"
	"io/fs"
	"os"
	"sync"
	"sync/atomic"
)

// part is what one entry on the way to a path is: there or not, and
// where it points when it is a link (a symlink, or on Windows a junction).
type part struct {
	there, link bool
	to          string
}

type partMemo struct {
	sync.Mutex
	m map[string]part
}

// reading is the memo of the read in progress, nil when there is none.
var reading atomic.Pointer[partMemo]

// readParts keeps what lookPart finds until the returned func is called.
// Only a read of the page that holds mu calls it: no change can make or
// take away a link while it does, since every change holds mu too. A
// caller without mu meanwhile (a probe of a folder to add) is given what
// the read found, at most as old as the read.
func readParts() (done func()) {
	reading.Store(&partMemo{m: map[string]part{}})
	return func() { reading.Store(nil) }
}

// lookPart is what the entry at p is, as found once in this read.
func lookPart(p string) part {
	pm := reading.Load()
	if pm == nil {
		e, _ := lookAt(p)
		return e
	}
	pm.Lock()
	e, ok := pm.m[p]
	pm.Unlock()
	if ok {
		return e
	}
	e, sure := lookAt(p)
	if sure {
		pm.Lock()
		pm.m[p] = e
		pm.Unlock()
	}
	return e
}

// lookAt is statPart; a test counts the looks
var lookAt = statPart

// statPart looks at the entry at p: one Lstat, and a Readlink for a link.
// sure is false when it couldn't be looked at for another reason than
// its not being there: unknown, looked at again next time.
func statPart(p string) (e part, sure bool) {
	fi, err := os.Lstat(p)
	if err != nil {
		return part{}, errors.Is(err, fs.ErrNotExist)
	}
	if !linkEntry(fi) {
		return part{there: true}, true
	}
	to, err := os.Readlink(p)
	if err != nil || to == "" {
		// a link that can't be read is taken as an entry of its own, as
		// before; but it isn't kept
		return part{there: true}, false
	}
	return part{there: true, link: true, to: to}, true
}