1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
|
package main
import (
"errors"
"fmt"
"os"
"path/filepath"
"sort"
"strings"
)
type agent struct {
Name string
// Home is the agent's own config directory; finding it means the agent
// is in use here.
Home string
}
func (a agent) skillsDir() string { return filepath.Join(a.Home, "skills") }
func knownAgents() []agent {
home, _ := os.UserHomeDir()
env := func(key, fallback string) string {
if v := os.Getenv(key); v != "" {
return v
}
return fallback
}
xdgConfig := env("XDG_CONFIG_HOME", filepath.Join(home, ".config"))
return []agent{
{"claude", env("CLAUDE_CONFIG_DIR", filepath.Join(home, ".claude"))},
{"codex", env("CODEX_HOME", filepath.Join(home, ".codex"))},
{"opencode", filepath.Join(xdgConfig, "opencode")},
}
}
func agentNames() string {
var names []string
for _, a := range knownAgents() {
names = append(names, a.Name)
}
return strings.Join(names, ", ")
}
// targetAgents returns the agents named in the manifest, or every known agent
// found on this machine.
func (ws *workspace) targetAgents() ([]agent, error) {
known := knownAgents()
if len(ws.manifest.Agents) > 0 {
var out []agent
for _, n := range ws.manifest.Agents {
i := indexAgent(known, n)
if i < 0 {
return nil, fmt.Errorf("%s names unknown agent %q (known: %s)", ws.manifestPath, n, agentNames())
}
out = append(out, known[i])
}
return out, nil
}
var out []agent
for _, a := range known {
if fi, err := os.Stat(a.Home); err == nil && fi.IsDir() {
out = append(out, a)
}
}
if len(out) == 0 {
return nil, fmt.Errorf("found no agents to install into (looked for %s); set \"agents\" in %s", agentNames(), ws.manifestPath)
}
return out, nil
}
func indexAgent(agents []agent, name string) int {
for i, a := range agents {
if a.Name == name {
return i
}
}
return -1
}
type skillState int
const (
stateMissing skillState = iota
stateInstalled
stateStale // a link of ours to another checkout
stateConflict // something we did not put there
)
func (s skillState) String() string {
return [...]string{"missing", "installed", "outdated", "conflict"}[s]
}
func linkState(path, want string) skillState {
dest, err := os.Readlink(path)
switch {
case err == nil && dest == want:
return stateInstalled
case err == nil && ownedLink(dest):
return stateStale
case errors.Is(err, os.ErrNotExist):
return stateMissing
}
if _, statErr := os.Lstat(path); errors.Is(statErr, os.ErrNotExist) {
return stateMissing
}
return stateConflict
}
func ownedLink(dest string) bool {
return strings.HasPrefix(dest, filepath.Join(dataDir(), "checkouts")+string(filepath.Separator))
}
type change struct {
Agent, Skill, Action string
}
// link makes each agent's skills directory hold exactly the locked skills,
// as symlinks into their checkouts. It leaves anything it did not create
// alone and reports it as a conflict.
func (ws *workspace) link(dirs map[string]string, agents []agent) ([]change, []string, error) {
var changes []change
var conflicts []string
for _, a := range agents {
dir := a.skillsDir()
if err := os.MkdirAll(dir, 0o755); err != nil {
return changes, conflicts, err
}
names := make([]string, 0, len(dirs))
for n := range dirs {
names = append(names, n)
}
sort.Strings(names)
for _, n := range names {
path, want := filepath.Join(dir, n), dirs[n]
switch linkState(path, want) {
case stateInstalled:
continue
case stateConflict:
conflicts = append(conflicts, path)
continue
case stateStale:
if err := os.Remove(path); err != nil {
return changes, conflicts, err
}
changes = append(changes, change{a.Name, n, "updated"})
default:
changes = append(changes, change{a.Name, n, "installed"})
}
if err := os.Symlink(want, path); err != nil {
return changes, conflicts, err
}
}
entries, err := os.ReadDir(dir)
if err != nil {
return changes, conflicts, err
}
for _, e := range entries {
if _, ok := dirs[e.Name()]; ok {
continue
}
path := filepath.Join(dir, e.Name())
if dest, err := os.Readlink(path); err == nil && ownedLink(dest) {
if err := os.Remove(path); err != nil {
return changes, conflicts, err
}
changes = append(changes, change{a.Name, e.Name(), "removed"})
}
}
}
return changes, conflicts, nil
}
|
