mirror of
https://github.com/runkids/skillshare.git
synced 2026-11-19 02:17:09 +00:00
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
253 lines
7.8 KiB
Go
253 lines
7.8 KiB
Go
package plugin
|
|
|
|
import (
|
|
"bytes"
|
|
"context"
|
|
"encoding/json"
|
|
"errors"
|
|
"fmt"
|
|
"os"
|
|
"os/exec"
|
|
"path/filepath"
|
|
"slices"
|
|
"strings"
|
|
"sync"
|
|
"time"
|
|
)
|
|
|
|
// ErrCLIMissing marks the one host failure fixed by installing something rather than
|
|
// by opening the Agent. Hosts carrying it are grouped together in the dashboard, so the
|
|
// same sentence is not repeated once per Agent.
|
|
var ErrCLIMissing = errors.New("native CLI not on PATH")
|
|
|
|
// agentError names a fixed failure template so the dashboard can show it in the reader's
|
|
// language. message stays the English the CLI prints and is the fallback; cause is
|
|
// ErrCLIMissing when installing something, not opening the Agent, is the remedy. args fill
|
|
// the {placeholders} of the translated sentence, for the part only known at runtime.
|
|
type agentError struct {
|
|
cause error
|
|
key string
|
|
message string
|
|
args map[string]string
|
|
}
|
|
|
|
func (e agentError) Error() string { return e.message }
|
|
func (e agentError) Unwrap() error { return e.cause }
|
|
|
|
func runCommand(ctx context.Context, dir string, env []string, bin string, args ...string) ([]byte, error) {
|
|
ctx, cancel := context.WithTimeout(ctx, 90*time.Second)
|
|
defer cancel()
|
|
cmd := exec.CommandContext(ctx, bin, args...)
|
|
cmd.Dir = dir
|
|
// No shell, inherited stdin, or automatic native trust/command confirmation.
|
|
cmd.Env = append(append(os.Environ(), "GIT_TERMINAL_PROMPT=0"), env...)
|
|
var stdout, stderr bytes.Buffer
|
|
cmd.Stdout = &stdout
|
|
cmd.Stderr = &stderr
|
|
if err := cmd.Run(); err != nil {
|
|
if errors.Is(err, exec.ErrNotFound) {
|
|
return nil, agentError{cause: ErrCLIMissing, key: "plugins.error.cliMissing", message: fmt.Sprintf("%s CLI is not installed or not on PATH on the machine running Skillshare; install it there before syncing plugins", bin)}
|
|
}
|
|
if ctx.Err() != nil {
|
|
return nil, agentError{key: "plugins.error.timeout", message: fmt.Sprintf("%s timed out or was cancelled; inspect native status before retrying", bin)}
|
|
}
|
|
// Native output can contain credentials or command-source scripts.
|
|
return nil, agentError{key: "plugins.error.commandFailed", message: fmt.Sprintf("%s command failed; open the native client to resolve authentication, trust, or configuration", bin)}
|
|
}
|
|
// Some CLIs (Pi) print their version to stderr.
|
|
if stdout.Len() == 0 && slices.Equal(args, []string{"--version"}) {
|
|
return stderr.Bytes(), nil
|
|
}
|
|
return stdout.Bytes(), nil
|
|
}
|
|
|
|
func (s *Service) run(ctx context.Context, target string, args ...string) ([]byte, error) {
|
|
run := s.Run
|
|
if run == nil {
|
|
run = runCommand
|
|
}
|
|
dir := s.ProjectRoot
|
|
if dir == "" {
|
|
var err error
|
|
dir, err = os.UserHomeDir()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
}
|
|
// An account runs its Agent's CLI against the account's own config directory.
|
|
var env []string
|
|
if account, ok := s.account(target); ok {
|
|
env = append(env, accountEnv[account.Agent]+"="+account.Dir)
|
|
}
|
|
bin := s.agentOf(target)
|
|
if bin == "antigravity-cli" {
|
|
bin = "agy"
|
|
}
|
|
return run(ctx, dir, env, bin, args...)
|
|
}
|
|
|
|
func parseInventory(target string, data []byte, project string) ([]Installed, error) {
|
|
result := []Installed{}
|
|
if target == "codex" {
|
|
var envelope struct {
|
|
Installed json.RawMessage `json:"installed"`
|
|
}
|
|
if json.Unmarshal(data, &envelope) != nil || len(envelope.Installed) == 0 {
|
|
return nil, fmt.Errorf("unrecognized Codex plugin list schema")
|
|
}
|
|
if err := json.Unmarshal(envelope.Installed, &result); err != nil {
|
|
return nil, fmt.Errorf("invalid Codex installed list")
|
|
}
|
|
for i := range result {
|
|
r := &result[i]
|
|
r.ID = r.PluginID
|
|
if r.ID == "" && r.Name != "" && r.Marketplace != "" {
|
|
r.ID = r.Name + "@" + r.Marketplace
|
|
}
|
|
r.Scope = "user"
|
|
}
|
|
} else {
|
|
if err := json.Unmarshal(data, &result); err != nil || result == nil {
|
|
return nil, fmt.Errorf("unrecognized Claude plugin list schema")
|
|
}
|
|
}
|
|
filtered := []Installed{}
|
|
for _, item := range result {
|
|
item.EnabledKnown = true
|
|
if !validID(item.ID) {
|
|
return nil, fmt.Errorf("native plugin list contains an unsupported plugin identifier")
|
|
}
|
|
if target == "claude" {
|
|
if project == "" && item.Scope != "user" {
|
|
continue
|
|
}
|
|
if project != "" && (item.Scope != "project" || filepath.Clean(item.ProjectPath) != filepath.Clean(project)) {
|
|
continue
|
|
}
|
|
}
|
|
filtered = append(filtered, item)
|
|
}
|
|
return filtered, nil
|
|
}
|
|
|
|
func validID(id string) bool {
|
|
name, market, ok := strings.Cut(id, "@")
|
|
return ok && namePattern.MatchString(name) && namePattern.MatchString(market)
|
|
}
|
|
|
|
func (s *Service) host(ctx context.Context, target string) Host {
|
|
agent := s.agentOf(target)
|
|
if agent != "claude" && agent != "codex" {
|
|
return s.additionalHost(ctx, target)
|
|
}
|
|
h := Host{Target: target, Status: HostReady, Installed: []Installed{}}
|
|
if agent == "codex" && s.ProjectRoot != "" {
|
|
h.block("plugins.error.userScoped", "Codex native plugin installation is user-scoped; use global mode. Project operations never fall back to global.")
|
|
return h
|
|
}
|
|
version, err := s.run(ctx, target, "--version")
|
|
if err != nil {
|
|
h.fail(err)
|
|
return h
|
|
}
|
|
h.Version = strings.TrimSpace(string(version))
|
|
data, err := s.run(ctx, target, "plugin", "list", "--json")
|
|
if err != nil {
|
|
h.fail(err)
|
|
return h
|
|
}
|
|
h.Installed, err = parseInventory(agent, data, s.ProjectRoot)
|
|
if err != nil {
|
|
h.fail(err)
|
|
}
|
|
return h
|
|
}
|
|
|
|
// Packages is the part of the inventory that config alone answers, so the dashboard can
|
|
// draw the plugin list while Inventory is still waiting on each Agent's CLI.
|
|
func (s *Service) Packages() (*Inventory, error) {
|
|
cfg, err := s.load()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
return &Inventory{TargetDefinitions: s.TargetDefinitions(), Packages: cfg.packages, Hosts: []Host{}}, nil
|
|
}
|
|
|
|
func (s *Service) Inventory(ctx context.Context) (*Inventory, error) {
|
|
result, err := s.Packages()
|
|
if err != nil {
|
|
return nil, err
|
|
}
|
|
// Each Agent answers through its own CLI and none depends on another, so the slowest
|
|
// one sets the wait instead of the sum of all of them.
|
|
targets := s.targets()
|
|
result.Hosts = make([]Host, len(targets))
|
|
var wg sync.WaitGroup
|
|
for i, target := range targets {
|
|
wg.Go(func() { result.Hosts[i] = s.host(ctx, target) })
|
|
}
|
|
wg.Wait()
|
|
return result, nil
|
|
}
|
|
|
|
func (s *Service) nativeArgs(target, action, id string) ([]string, error) {
|
|
if action == "uninstall" {
|
|
action = "remove"
|
|
}
|
|
if !validID(id) {
|
|
return nil, fmt.Errorf("invalid plugin identity")
|
|
}
|
|
agent := s.agentOf(target)
|
|
if agent == "codex" {
|
|
if s.ProjectRoot != "" {
|
|
return nil, fmt.Errorf("Codex project plugin operations are unsupported")
|
|
}
|
|
switch action {
|
|
case "install":
|
|
return []string{"plugin", "add", id, "--json"}, nil
|
|
case "remove":
|
|
return []string{"plugin", "remove", id, "--json"}, nil
|
|
}
|
|
return nil, fmt.Errorf("Codex has no verified native %s command; manage this operation in Codex", action)
|
|
}
|
|
if agent != "claude" {
|
|
return nil, fmt.Errorf("unsupported plugin target %q", target)
|
|
}
|
|
if action == "install" || action == "update" || action == "remove" {
|
|
command := action
|
|
if action == "remove" {
|
|
command = "uninstall"
|
|
}
|
|
scope := "user"
|
|
if s.ProjectRoot != "" {
|
|
scope = "project"
|
|
}
|
|
args := []string{"plugin", command, id, "--scope", scope}
|
|
if action == "install" || action == "update" {
|
|
args = append(args, "--json")
|
|
}
|
|
return args, nil
|
|
}
|
|
return nil, fmt.Errorf("unsupported plugin action %q", action)
|
|
}
|
|
|
|
func (s *Service) verifyCommand(ctx context.Context, target, action, id string) error {
|
|
if agent := s.agentOf(target); agent != "claude" && agent != "codex" {
|
|
return s.verifyAdditional(ctx, target, action, id)
|
|
}
|
|
args, err := s.nativeArgs(target, action, id)
|
|
if err != nil {
|
|
return err
|
|
}
|
|
help, err := s.run(ctx, target, "plugin", args[1], "--help")
|
|
if err != nil {
|
|
return err
|
|
}
|
|
for _, flag := range args {
|
|
if strings.HasPrefix(flag, "--") && !strings.Contains(string(help), flag) {
|
|
return fmt.Errorf("installed %s does not support %s for %s; upgrade the native CLI", target, flag, action)
|
|
}
|
|
}
|
|
return nil
|
|
}
|