113 lines
2.2 KiB
Go
113 lines
2.2 KiB
Go
package toolsrv
|
|
|
|
import (
|
|
"fmt"
|
|
"os"
|
|
"sort"
|
|
"sync"
|
|
)
|
|
|
|
type Registry struct {
|
|
mu sync.RWMutex
|
|
sessions map[string]map[string]ToolInfo
|
|
revisions map[string]uint64
|
|
}
|
|
|
|
func NewRegistry() (*Registry, error) {
|
|
r := &Registry{
|
|
sessions: make(map[string]map[string]ToolInfo),
|
|
revisions: make(map[string]uint64),
|
|
}
|
|
// Validate that the tools directory is readable.
|
|
dir := ToolsPath()
|
|
if _, err := os.ReadDir(dir); err != nil {
|
|
return nil, fmt.Errorf("read tools dir %s: %w", dir, err)
|
|
}
|
|
return r, nil
|
|
}
|
|
|
|
// discover scans the tools directory and returns all valid tool infos.
|
|
func (r *Registry) discover() map[string]ToolInfo {
|
|
infos := DiscoverTools()
|
|
tools := make(map[string]ToolInfo, len(infos))
|
|
for _, info := range infos {
|
|
tools[info.Name] = info
|
|
}
|
|
return tools
|
|
}
|
|
|
|
func (r *Registry) Load(sessionID, name string) error {
|
|
tools := r.discover()
|
|
tool, exists := tools[name]
|
|
if !exists {
|
|
return fmt.Errorf("tool not found: %s", name)
|
|
}
|
|
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
|
|
if r.sessions[sessionID] == nil {
|
|
r.sessions[sessionID] = make(map[string]ToolInfo)
|
|
}
|
|
|
|
r.sessions[sessionID][name] = tool
|
|
r.revisions[sessionID]++
|
|
return nil
|
|
}
|
|
|
|
func (r *Registry) Unload(sessionID, name string) error {
|
|
r.mu.Lock()
|
|
defer r.mu.Unlock()
|
|
|
|
sessionTools, ok := r.sessions[sessionID]
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
if _, exists := sessionTools[name]; !exists {
|
|
return nil
|
|
}
|
|
|
|
delete(sessionTools, name)
|
|
r.revisions[sessionID]++
|
|
return nil
|
|
}
|
|
|
|
func (r *Registry) Loaded(sessionID string) []ToolInfo {
|
|
r.mu.RLock()
|
|
defer r.mu.RUnlock()
|
|
|
|
sessionTools, ok := r.sessions[sessionID]
|
|
if !ok {
|
|
return nil
|
|
}
|
|
|
|
var loaded []ToolInfo
|
|
for _, info := range sessionTools {
|
|
loaded = append(loaded, info)
|
|
}
|
|
sort.Slice(loaded, func(i, j int) bool { return loaded[i].Name < loaded[j].Name })
|
|
return loaded
|
|
}
|
|
|
|
func (r *Registry) Lookup(sessionID, name string) (ToolInfo, bool) {
|
|
r.mu.RLock()
|
|
defer r.mu.RUnlock()
|
|
|
|
sessionTools, ok := r.sessions[sessionID]
|
|
if !ok {
|
|
return ToolInfo{}, false
|
|
}
|
|
|
|
tool, exists := sessionTools[name]
|
|
return tool, exists
|
|
}
|
|
|
|
func (r *Registry) Revision(sessionID string) uint64 {
|
|
r.mu.RLock()
|
|
defer r.mu.RUnlock()
|
|
return r.revisions[sessionID]
|
|
}
|
|
|
|
|