Files
skillshare/internal/plugin/accounts.go
T
Willie bb57a9af9c feat(targets): add account targets for a second Claude, Codex or Pi config directory
A target declared with `agent` and `config_dir` is another config directory of a
built-in Agent, such as a second Claude account. Its skills and agents paths are
derived from the Agent's defaults at load time, so the config only records the
directory. The same target name works for MCP (written in the Agent's format into
the account's own file), for plugins (the Agent CLI runs with CLAUDE_CONFIG_DIR,
CODEX_HOME or PI_CODING_AGENT_DIR) and for `mcp import --from`. Removing such a
target warns when MCP config still names it instead of failing later at sync.

The dashboard gains an "another account" mode in the add-target dialog and lists
accounts next to the Agents on the MCP and plugin pages.

Refs #289
2026-09-22 11:21:35 +08:00

106 lines
3.2 KiB
Go

package plugin
import (
"context"
"slices"
"sort"
)
// Account is a target that is another config directory of a built-in Agent, such as a
// second Claude account. Its plugins are installed by the Agent's own CLI, run against Dir.
type Account struct {
Agent string
Dir string
}
// accountEnv names, for each Agent whose plugins follow its config directory, the
// environment variable that points its CLI at another one. Only these Agents have accounts.
var accountEnv = map[string]string{"claude": "CLAUDE_CONFIG_DIR", "codex": "CODEX_HOME", "pi": "PI_CODING_AGENT_DIR"}
// account resolves a target that is another config directory of an Agent. A project's
// plugins belong to the project rather than to one account, so accounts are global only.
func (s *Service) account(target string) (Account, bool) {
a, ok := s.Accounts[target]
if !ok || s.ProjectRoot != "" || a.Dir == "" {
return Account{}, false
}
_, supported := accountEnv[a.Agent]
return a, supported
}
// agentOf is the Agent that runs a target: an account's Agent, or the target itself.
func (s *Service) agentOf(target string) string {
if a, ok := s.account(target); ok {
return a.Agent
}
return target
}
// accountNames lists this configuration's accounts, in the order they are shown.
func (s *Service) accountNames() []string {
names := []string{}
for name := range s.Accounts {
if _, ok := s.account(name); ok {
names = append(names, name)
}
}
sort.Strings(names)
return names
}
// accountAgents maps each account to its Agent, for the checks that read config alone.
func (s *Service) accountAgents() map[string]string {
agents := map[string]string{}
for _, name := range s.accountNames() {
agents[name] = s.Accounts[name].Agent
}
return agents
}
// targets are the plugin targets of this configuration: the built-in Agents and its accounts.
func (s *Service) targets() []string {
return append(slices.Clone(Targets), s.accountNames()...)
}
// TargetDefinitions adds this configuration's accounts to the built-in targets. An account
// takes the operations of the Agent it is another config directory of.
func (s *Service) TargetDefinitions() []TargetDefinition {
definitions := TargetDefinitions()
accounts := []TargetDefinition{}
for _, name := range s.accountNames() {
for _, d := range definitions {
if d.Target == s.Accounts[name].Agent {
d.Target, d.Label, d.Project = name, name, false
accounts = append(accounts, d)
break
}
}
}
return append(definitions, accounts...)
}
// Discover resolves a source for this configuration. An account takes the entries of the
// Agent it is another config directory of, so it is offered wherever that Agent is.
func (s *Service) Discover(ctx context.Context, source, ref, entry string) (*Discovery, error) {
d, err := DiscoverOptions(ctx, source, ref, entry)
if err != nil {
return nil, err
}
d.TargetDefinitions = s.TargetDefinitions()
for i := range d.Candidates {
c := &d.Candidates[i]
for _, name := range s.accountNames() {
info, ok := c.TargetInfo[s.Accounts[name].Agent]
if !ok {
continue
}
c.TargetInfo[name] = info
if info.Problem == "" && !slices.Contains(c.Targets, name) {
c.Targets = append(c.Targets, name)
}
}
slices.Sort(c.Targets)
}
return d, nil
}