Skip to content

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

40.1 KB
Raw Blame
package library

import (
	"bytes"
	"context"
	"encoding/json"
	"errors"
	"fmt"
	"os"
	"path/filepath"
	"regexp"
	"runtime"
	"slices"
	"strings"
	"sync"
	"time"

	"github.com/pelletier/go-toml/v2"
	"github.com/yetone/magpie/internal/agent"
	"github.com/yetone/magpie/internal/appdir"
	"github.com/yetone/magpie/internal/edit"
	"github.com/yetone/magpie/internal/filememo"
	"github.com/yetone/magpie/internal/proc"
	"gopkg.in/yaml.v3"
)

// RTK (rtk-ai.app) is a CLI that the shell commands an agent runs go
// through — git status, cargo test, ls — cut down to what the model needs,
// so their output costs fewer tokens. Each agent gets it through a hook its
// own installer writes (rtk init -g …): magpie runs that installer for the
// agents switched on, takes out what it wrote for those switched off, and
// reads each one's files to say which have it, since rtk init --show knows
// only of Claude Code, OpenCode and Cursor.

// RTKURL is where rtk is installed from.
const RTKURL = "https://www.rtk-ai.app"

// rtkSpec is how rtk's installer names one agent, and what it writes there.
type rtkSpec struct {
	flags []string // after rtk init -g
	// patch: the installer takes --auto-patch (Codex's refuses it)
	patch bool
	// has says whether the agent has rtk's hook, by its files
	has func(a *agent.Agent) bool
	// files are those the installer writes and remove takes back, kept
	// aside by magpie first
	files func(a *agent.Agent) []string
	// remove takes out what the installer put in, and only that. It is
	// magpie's own, not rtk init --uninstall: it works with rtk gone (its
	// hooks left behind then fail every command), and rtk's uninstaller
	// deletes Gemini's GEMINI.md whole and takes Claude Code, OpenCode and
	// Cursor away together.
	remove func(a *agent.Agent) error
	// dir is the agent's folder, made first: rtk writes nothing for an
	// agent whose folder isn't there yet
	dir func(a *agent.Agent) string
	// withClaude: the installer gives it to Claude Code too, which is
	// pointed at a folder thrown away after
	withClaude bool
	// env is what the installer is run with besides magpie's own
	// environment, so it writes where the agent reads
	env func(a *agent.Agent) []string
	// blocked says why rtk's installer mustn't be run for the agent as it
	// is where it lives (this machine, or its WSL distro), "" when it can be
	blocked func(a *agent.Agent) string
}

func contains(path, s string) bool {
	b, err := os.ReadFile(path)
	return err == nil && bytes.Contains(b, []byte(s))
}

func exists(path string) bool {
	_, err := os.Stat(path)
	return err == nil
}

// rtkRef is the line rtk adds to an instructions file to pull its own in:
// @RTK.md, or @ and RTK.md's whole path.
func rtkRef(line string) bool {
	t := strings.TrimSpace(line)
	return strings.HasPrefix(t, "@") && (t == "@RTK.md" || strings.HasSuffix(t, "/RTK.md") || strings.HasSuffix(t, `\RTK.md`))
}

var rtkSpecs = map[string]rtkSpec{
	"claude": {
		patch: true,
		has: func(a *agent.Agent) bool {
			return contains(filepath.Join(rtkClaudeDir(a), "settings.json"), "rtk hook claude")
		},
		files: func(a *agent.Agent) []string {
			d := rtkClaudeDir(a)
			return []string{filepath.Join(d, "settings.json"), filepath.Join(d, "CLAUDE.md"), filepath.Join(d, "RTK.md")}
		},
		remove: func(a *agent.Agent) error {
			d := rtkClaudeDir(a)
			return errors.Join(
				dropHook(filepath.Join(d, "settings.json"), "hooks.PreToolUse", "rtk hook claude"),
				dropLines(filepath.Join(d, "CLAUDE.md"), rtkRef),
				rm(filepath.Join(d, "RTK.md")))
		},
		dir: func(a *agent.Agent) string { return rtkClaudeDir(a) },
	},
	"codex": {
		flags:   []string{"--codex"},
		blocked: codexBlocked,
		has: func(a *agent.Agent) bool {
			return contains(filepath.Join(rtkCodexDir(a), "hooks.json"), "rtk hook codex")
		},
		files: func(a *agent.Agent) []string {
			d := rtkCodexDir(a)
			return []string{filepath.Join(d, "hooks.json"), filepath.Join(d, "AGENTS.md"), filepath.Join(d, "RTK.md")}
		},
		remove: func(a *agent.Agent) error {
			d := rtkCodexDir(a)
			return errors.Join(
				dropHook(filepath.Join(d, "hooks.json"), "hooks.PreToolUse", "rtk hook codex"),
				dropLines(filepath.Join(d, "AGENTS.md"), rtkRef),
				rm(filepath.Join(d, "RTK.md")))
		},
		dir: func(a *agent.Agent) string { return rtkCodexDir(a) },
	},
	"gemini": {
		// --hook-only: without it the installer writes its own GEMINI.md
		// over the user's
		flags: []string{"--gemini", "--hook-only"}, patch: true,
		has: func(a *agent.Agent) bool {
			return contains(filepath.Join(rtkHome(a), ".gemini", "settings.json"), "rtk-hook-gemini")
		},
		files: func(a *agent.Agent) []string {
			d := filepath.Join(rtkHome(a), ".gemini")
			return []string{filepath.Join(d, "settings.json"), filepath.Join(d, "hooks", "rtk-hook-gemini.sh"), filepath.Join(d, "hooks", ".rtk-hook.sha256")}
		},
		remove: func(a *agent.Agent) error {
			d := filepath.Join(rtkHome(a), ".gemini")
			err := errors.Join(
				dropHook(filepath.Join(d, "settings.json"), "hooks.BeforeTool", "rtk-hook-gemini"),
				rm(filepath.Join(d, "hooks", "rtk-hook-gemini.sh"), filepath.Join(d, "hooks", ".rtk-hook.sha256")))
			os.Remove(filepath.Join(d, "hooks")) // when nothing else is in it
			return err
		},
		dir: func(a *agent.Agent) string { return filepath.Join(rtkHome(a), ".gemini") },
	},
	"opencode": {
		flags: []string{"--opencode"}, patch: true, withClaude: true, blocked: openCodeBlocked,
		has:    openCodeHas,
		files:  func(a *agent.Agent) []string { return []string{opencodePlugin(a)} },
		remove: func(a *agent.Agent) error { return rm(opencodePlugin(a)) },
		dir:    func(a *agent.Agent) string { return filepath.Dir(a.Path) },
	},
	"cursor": {
		flags: []string{"--agent", "cursor"}, patch: true, withClaude: true,
		has: func(a *agent.Agent) bool {
			return contains(filepath.Join(rtkHome(a), ".cursor", "hooks.json"), "rtk hook cursor")
		},
		files: func(a *agent.Agent) []string { return []string{filepath.Join(rtkHome(a), ".cursor", "hooks.json")} },
		remove: func(a *agent.Agent) error {
			return dropHook(filepath.Join(rtkHome(a), ".cursor", "hooks.json"), "hooks.preToolUse", "rtk hook cursor")
		},
		dir: func(a *agent.Agent) string { return filepath.Join(rtkHome(a), ".cursor") },
	},
	"copilot": {
		flags: []string{"--copilot"}, patch: true,
		has: func(a *agent.Agent) bool {
			return exists(filepath.Join(rtkHome(a), ".copilot", "hooks", "rtk-rewrite.json"))
		},
		files: func(a *agent.Agent) []string {
			d := filepath.Join(rtkHome(a), ".copilot")
			return []string{filepath.Join(d, "hooks", "rtk-rewrite.json"), filepath.Join(d, "copilot-instructions.md")}
		},
		remove: func(a *agent.Agent) error {
			d := filepath.Join(rtkHome(a), ".copilot")
			return errors.Join(
				rm(filepath.Join(d, "hooks", "rtk-rewrite.json")),
				dropBlock(filepath.Join(d, "copilot-instructions.md"), "<!-- rtk-instructions", "<!-- /rtk-instructions -->"))
		},
		dir: func(a *agent.Agent) string { return filepath.Join(rtkHome(a), ".copilot") },
	},
	// Antigravity CLI (agy): rtk 0.51 on writes a plugin of its own into
	// Antigravity's global customization folder, ~/.gemini/config, shared
	// by the CLI and the IDE (src/hooks/init/antigravity.rs): plugin.json,
	// hooks.json (PreToolUse → rtk hook antigravity) and rules/AGENTS.md,
	// all in plugins/rtk. agy discovers a plugin there by its plugin.json.
	// The Antigravity branch reads no patch mode, so --auto-patch isn't
	// given; rtk's own uninstaller for it ran Claude Code's
	// (rtk-ai/rtk#3404), so the folder is taken out by magpie.
	"agy": {
		flags: []string{"--agent", "antigravity"}, blocked: agyBlocked,
		has: func(a *agent.Agent) bool {
			return contains(filepath.Join(agyPlugin(a), "hooks.json"), "rtk hook antigravity")
		},
		files: func(a *agent.Agent) []string {
			d := agyPlugin(a)
			return []string{filepath.Join(d, "plugin.json"), filepath.Join(d, "hooks.json"), filepath.Join(d, "rules", "AGENTS.md")}
		},
		remove: func(a *agent.Agent) error { return os.RemoveAll(agyPlugin(a)) },
		dir:    func(a *agent.Agent) string { return filepath.Dir(filepath.Dir(agyPlugin(a))) },
	},
	"pi":  extensionSpec("pi"),
	"omp": extensionSpec("omp"),
	// Hermes's folder is the agent's (appdir.HermesHome): $HERMES_HOME,
	// else %LOCALAPPDATA%\hermes on Windows and ~/.hermes elsewhere. rtk
	// (0.51, src/hooks/init/hermes.rs) knows only $HERMES_HOME and
	// ~/.hermes, so it is told the folder: on Windows it otherwise writes
	// its plugin where Hermes doesn't look (新v学员 on Discord).
	"hermes": {
		flags: []string{"--agent", "hermes"}, patch: true,
		has: func(a *agent.Agent) bool { return exists(filepath.Join(hermesPlugin(a), "plugin.yaml")) },
		files: func(a *agent.Agent) []string {
			return []string{filepath.Join(a.Dir, "config.yaml"), filepath.Join(hermesPlugin(a), "plugin.yaml"), filepath.Join(hermesPlugin(a), "__init__.py")}
		},
		remove: func(a *agent.Agent) error {
			return errors.Join(os.RemoveAll(hermesPlugin(a)), dropHermesPlugin(filepath.Join(a.Dir, "config.yaml")))
		},
		dir: func(a *agent.Agent) string { return a.Dir },
		env: func(a *agent.Agent) []string { return []string{"HERMES_HOME=" + a.Dir} },
	},
}

// rtkNoHook are agents RTK has no hook for, and why: the Library lists
// them all the same, so one isn't simply missing as if magpie hadn't seen
// it (Discord, lc: rtk 没有识别 deepseek harness).
//
// DeepSeek Harness: RTK works by rewriting the shell command an agent is
// about to run (git status → rtk git status), and dsh has no way for a hook
// to do that — its pre-tool hooks only allow, deny or ask, and its Claude
// Code hook bridge drops updatedInput (deepseek-harness's
// pre-tool-input-rewrite note is only proposed). rtk init has no
// --agent dsh either (rtk 0.51; rtk-ai/rtk#3847, and #3934 only adds
// instructions to AGENTS.md, which rewrite nothing).
var rtkNoHook = map[string]string{
	"dsh": "RTK has no hook for DeepSeek Harness yet: RTK works by rewriting the shell command an agent is about to run, and dsh's hooks can only allow or deny a command, not change it; rtk init has no --agent dsh either (github.com/rtk-ai/rtk/issues/3847)",
	// rtk init's agents are claude, cursor, codex, copilot, gemini,
	// opencode and the rest of rtkSpecs (src/hooks/init in rtk 1.0.1).
	// There is no grok or grok-app, so a hook written here would have
	// nowhere to go, for Grok Build no more than for the App that runs it.
	// rtk-ai/rtk#2136 asks for Grok Build, and Grok App runs Grok Build,
	// so the two share it on purpose (sharedRTKIssues in the test).
	"grok":     "RTK has no hook for Grok Build yet: rtk init has no Grok agent, so it cannot rewrite the shell commands Grok Build runs (github.com/rtk-ai/rtk/issues/2136)",
	"grok-app": "RTK has no hook for Grok App yet: rtk init has no Grok or Grok App agent, so it cannot rewrite the shell commands Grok App runs (github.com/rtk-ai/rtk/issues/2136)",
}

func opencodePlugin(a *agent.Agent) string {
	return filepath.Join(filepath.Dir(a.Path), "plugins", "rtk.ts")
}

// openCodeBlocked: rtk's OpenCode plugin (hooks/opencode/rtk.ts, which
// rtk init --opencode writes to plugins/rtk.ts) was written for OpenCode
// 1's plugin API up to rtk 0.51 — a named export of a function. OpenCode 2
// reads the same plugins folder but takes only a default export of
// {id, setup|effect}, and turns that one away: "Plugin must export a
// default definition with an id and an effect or setup function"
// (rtk-ai/rtk#4311, #3898). rtk 0.52 on (rtk-ai/rtk#4187, in 0.52.0,
// 1.0.0 and 1.0.1) writes one default object with OpenCode 2's id and
// setup() beside OpenCode 1's server(). So with an OpenCode 2 here, rtk is
// given to OpenCode only by an rtk of 0.52 or newer; an older one, or one
// that doesn't say its version, would only add a plugin that fails to load.
func openCodeBlocked(a *agent.Agent) string {
	v := openCodeVersionOf(a)
	if !openCode2(v) {
		return ""
	}
	r := rtkVersionOf(a)
	if r != "" && !older(r, 0, 52) {
		return ""
	}
	if r == "" {
		return fmt.Sprintf("OpenCode %s needs RTK 0.52 or newer, whose plugin OpenCode 2 loads; older ones write a plugin for OpenCode 1, which OpenCode 2 refuses to load (github.com/rtk-ai/rtk/issues/4311). Install or update RTK, then switch it on", v)
	}
	return fmt.Sprintf("OpenCode %s needs RTK 0.52 or newer, and this RTK is %s, whose plugin is written for OpenCode 1: OpenCode 2 refuses to load it (github.com/rtk-ai/rtk/issues/4311). Update RTK (brew upgrade rtk, or its installer again), then switch it on", v, r)
}

// openCode2 says whether OpenCode version v is 2 or later.
func openCode2(v string) bool {
	major, _, _ := strings.Cut(v, ".")
	return major != "" && major != "0" && major != "1"
}

// openCodeHas says whether OpenCode has rtk's plugin. Under OpenCode 2 a
// plugin an rtk before 0.52 wrote (no setup(), OpenCode 1's API only) is
// refused at load. With an rtk here that writes the new one, that old
// plugin doesn't count: the row is off, and switching it on runs rtk's
// installer, which writes the new one over it. With an older rtk it still
// counts, so the row can be switched off to take it out.
func openCodeHas(a *agent.Agent) bool {
	p := opencodePlugin(a)
	if !exists(p) {
		return false
	}
	if contains(p, "setup(") || !openCode2(openCodeVersionOf(a)) {
		return true
	}
	return openCodeBlocked(a) != ""
}

// codexBlocked: rtk has a hook for Codex from 0.50.0 on (rtk hook codex in
// hooks.json); before that rtk init --codex only puts @RTK.md in AGENTS.md,
// which rewrites no command, so an older rtk isn't run for Codex.
func codexBlocked(a *agent.Agent) string {
	v := rtkVersionOf(a)
	if v == "" || !older(v, 0, 50) {
		return ""
	}
	return fmt.Sprintf("Codex's hook needs RTK 0.50 or newer, and this RTK is %s: older ones only add @RTK.md to AGENTS.md, which rewrites no command. Update RTK (brew upgrade rtk, or its installer again), then switch it on", v)
}

// agyPlugin is the folder rtk's installer writes its Antigravity plugin to.
func agyPlugin(a *agent.Agent) string {
	return filepath.Join(rtkHome(a), ".gemini", "config", "plugins", "rtk")
}

// agyBlocked: rtk installs for Antigravity globally from 0.51.0 on; 0.50
// knows it only per project and fails rtk init -g --agent antigravity
// ("Antigravity is project-scoped"), so an older rtk isn't run for it.
func agyBlocked(a *agent.Agent) string {
	v := rtkVersionOf(a)
	if v == "" || !older(v, 0, 51) {
		return ""
	}
	return fmt.Sprintf("Antigravity CLI's hook needs RTK 0.51 or newer, and this RTK is %s, which installs it only per project, not for every project. Update RTK (brew upgrade rtk, or its installer again), then switch it on", v)
}

// older says whether version v is before major.minor.
func older(v string, major, minor int) bool {
	var a, b int
	if n, _ := fmt.Sscanf(v, "%d.%d", &a, &b); n < 2 {
		return false
	}
	return a < major || a == major && b < minor
}

// rtkVersion is the version the rtk here says it is, "" when there's none
// or it doesn't say; a test sets it.
var rtkVersion = func() string {
	bin := rtkPath()
	if bin == "" {
		return ""
	}
	out, err := rtkRun(bin, "--version")
	if err != nil {
		return ""
	}
	if m := semver.FindStringSubmatch(out); m != nil {
		return m[1]
	}
	return ""
}

// semver finds the version in what opencode --version prints: OpenCode 1
// prints "1.18.32", OpenCode 2 "opencode v2.0.18".
var semver = regexp.MustCompile(`(?:^|[^\w.])v?(\d+\.\d+\.\d+\S*)`)

// openCodeVersion is the version the opencode on this machine says it is,
// "" when there's none or it doesn't say; a test sets it. OpenCode 2's
// installer puts it in ~/.opencode/bin as opencode, with opencode2 beside
// it running it.
var openCodeVersion = func() string {
	name := "opencode"
	if runtime.GOOS == "windows" {
		name = "opencode.exe"
	}
	bin, err := proc.Look("opencode")
	if err != nil {
		bin = filepath.Join(home(), ".opencode", "bin", name)
		if !exists(bin) {
			return ""
		}
	}
	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
	defer cancel()
	cmd := proc.ProbeContext(ctx, bin, "--version")
	cmd.Stdin = nil
	out, err := cmd.Output()
	if err != nil {
		return ""
	}
	if m := semver.FindStringSubmatch(string(out)); m != nil {
		return m[1]
	}
	return ""
}

func hermesPlugin(a *agent.Agent) string { return filepath.Join(a.Dir, "plugins", "rtk-rewrite") }

// extensionSpec is pi's and omp's: an extension of rtk's own, and nothing else.
func extensionSpec(id string) rtkSpec {
	ext := func(a *agent.Agent) string { return filepath.Join(rtkHome(a), "."+id, "agent", "extensions", "rtk.ts") }
	return rtkSpec{
		flags: []string{"--agent", id}, patch: true,
		has:    func(a *agent.Agent) bool { return exists(ext(a)) },
		files:  func(a *agent.Agent) []string { return []string{ext(a)} },
		remove: func(a *agent.Agent) error { return rm(ext(a)) },
		dir:    func(a *agent.Agent) string { return filepath.Join(rtkHome(a), "."+id, "agent") },
	}
}

func rm(paths ...string) error {
	var errs []error
	for _, p := range paths {
		if err := os.Remove(p); err != nil && !os.IsNotExist(err) {
			errs = append(errs, err)
		}
	}
	return errors.Join(errs...)
}

// dropHook takes the hooks whose command has mark out of the array at key:
// Claude Code's, Codex's and Gemini's are groups, each with its own hooks,
// a group left with none going too; Cursor's are the hooks themselves. An
// array left empty goes, and hooks with it when that leaves it empty.
func dropHook(path, key, mark string) error {
	raw, ok := edit.GetJSON(path, key)
	if !ok {
		return nil
	}
	var list []json.RawMessage
	if json.Unmarshal([]byte(raw), &list) != nil {
		return fmt.Errorf("%s: %s isn't a list", path, key)
	}
	var keep []json.RawMessage
	changed := false
	for _, e := range list {
		var h struct {
			Command string            `json:"command"`
			Hooks   []json.RawMessage `json:"hooks"`
		}
		json.Unmarshal(e, &h)
		if strings.Contains(h.Command, mark) {
			changed = true
			continue
		}
		if h.Hooks != nil && bytes.Contains(e, []byte(mark)) {
			var inner []json.RawMessage
			for _, x := range h.Hooks {
				var c struct {
					Command string `json:"command"`
				}
				json.Unmarshal(x, &c)
				if !strings.Contains(c.Command, mark) {
					inner = append(inner, x)
				}
			}
			if len(inner) < len(h.Hooks) {
				changed = true
				if len(inner) == 0 {
					continue
				}
				var g map[string]json.RawMessage
				json.Unmarshal(e, &g)
				g["hooks"], _ = json.Marshal(inner)
				e, _ = json.Marshal(g)
			}
		}
		keep = append(keep, e)
	}
	if !changed {
		return nil
	}
	if len(keep) > 0 {
		return edit.SetJSON(path, edit.KV{Path: key, Value: keep})
	}
	if err := edit.DelJSON(path, key); err != nil {
		return err
	}
	parent := key[:strings.LastIndex(key, ".")]
	if v, ok := edit.GetJSON(path, parent); ok && strings.TrimSpace(v) == "{}" {
		return edit.DelJSON(path, parent)
	}
	return nil
}

// dropLines takes out the lines match says are rtk's, with the blank line
// rtk put before one; a file left with nothing in it goes.
func dropLines(path string, match func(string) bool) error {
	b, err := os.ReadFile(path)
	if os.IsNotExist(err) {
		return nil
	}
	if err != nil {
		return err
	}
	ls := strings.Split(string(b), "\n")
	var out []string
	for i, l := range ls {
		if !match(l) {
			out = append(out, l)
			continue
		}
		next := ""
		if i+1 < len(ls) {
			next = ls[i+1]
		}
		if n := len(out); n > 0 && strings.TrimSpace(out[n-1]) == "" && strings.TrimSpace(next) == "" {
			out = out[:n-1]
		}
	}
	if len(out) == len(ls) {
		return nil
	}
	return writeOrRemove(path, strings.Join(out, "\n"))
}

// dropBlock takes out the lines from the one with open to the one with
// close, as dropLines does.
func dropBlock(path, open, close string) error {
	in := false
	return dropLines(path, func(l string) bool {
		switch {
		case strings.Contains(l, open):
			in = true
		case in && strings.Contains(l, close):
			in = false
			return true
		}
		return in
	})
}

func writeOrRemove(path, s string) error {
	if strings.TrimSpace(s) == "" {
		return edit.Remove(path)
	}
	return edit.WriteAtomic(path, []byte(s))
}

// dropHermesPlugin takes rtk-rewrite out of Hermes' plugins.enabled, and
// the keys rtk added for it when that leaves them empty.
func dropHermesPlugin(path string) error {
	if err := dropLines(path, func(l string) bool { return strings.TrimSpace(l) == "- rtk-rewrite" }); err != nil {
		return err
	}
	var c struct {
		Plugins map[string]any `yaml:"plugins"`
	}
	b, err := os.ReadFile(path)
	if err != nil || yaml.Unmarshal(b, &c) != nil || c.Plugins == nil {
		return nil
	}
	if l, ok := c.Plugins["enabled"]; ok && (l == nil || fmt.Sprint(l) == "[]") {
		if err := edit.DelYAML(path, "plugins.enabled"); err != nil {
			return err
		}
		delete(c.Plugins, "enabled")
	}
	if len(c.Plugins) == 0 {
		return edit.DelYAML(path, "plugins")
	}
	return nil
}

// RTKAgent is one agent rtk can be given to, and whether it has it.
type RTKAgent struct {
	ID   string `json:"id"`
	Name string `json:"name"`
	Icon string `json:"icon"`
	On   bool   `json:"on"`
	// Blocked says why rtk can't be switched on for it here (OpenCode 2);
	// one that has it can still be switched off
	Blocked string `json:"blocked,omitempty"`
	// NoHook: rtk has no hook for it at all (rtkNoHook), and Blocked says why
	NoHook bool `json:"noHook,omitempty"`
	// WSL is the distro an agent in WSL lives in: its hook runs the rtk
	// of that distro (RTKView.WSL), not this machine's
	WSL string `json:"wsl,omitempty"`
	// Asleep: its distro isn't running, so its files aren't read (that
	// would start it) and On isn't known
	Asleep bool `json:"asleep,omitempty"`
}

// RTKGain is what rtk says it saved, over every command it has recorded.
type RTKGain struct {
	Commands int     `json:"commands"`
	Input    int64   `json:"input"`
	Saved    int64   `json:"saved"`
	Pct      float64 `json:"pct"`
}

// RTKDay is what rtk saved on one day it ran commands.
type RTKDay struct {
	Date     string  `json:"date"` // 2006-01-02, local
	Commands int     `json:"commands"`
	Input    int64   `json:"input"`
	Saved    int64   `json:"saved"`
	Pct      float64 `json:"pct"`
}

// RTKView is the RTK part of the Library page.
type RTKView struct {
	Path    string   `json:"path,omitempty"` // "" when rtk isn't installed
	Version string   `json:"version,omitempty"`
	Gain    *RTKGain `json:"gain,omitempty"`
	// GainErr is why what rtk saved isn't known: rtk gain failed or
	// printed nothing readable
	GainErr string `json:"gainErr,omitempty"`
	// CodexSandbox is the Windows sandbox Codex runs its commands in,
	// when it has rtk: what rtk saves there isn't counted in Gain
	CodexSandbox string `json:"codexSandbox,omitempty"`
	// Days are what it saved each day it ran commands, oldest first
	Days []RTKDay `json:"days,omitempty"`
	// Latest is rtk's latest release, "" when it isn't known (see
	// CheckLatest); Upgrade the command Upgrade RTK runs, "" when magpie
	// doesn't know how this rtk was installed
	Latest  string `json:"latest,omitempty"`
	Upgrade string `json:"upgrade,omitempty"`
	// NoUpgrade is why there is no Upgrade when magpie knows: "cargo", an
	// rtk cargo installed with no cargo to be found to upgrade it, which
	// the page says with Manual, the command to run in a terminal once
	// there is (新v学员: its Upgrade button only did nothing)
	NoUpgrade string `json:"noUpgrade,omitempty"`
	Manual    string `json:"manual,omitempty"`
	// Admin is the folder rtk is in when only an administrator can change
	// it (winget's for every user, under Program Files): Upgrade asks
	// Windows for one first
	Admin string `json:"admin,omitempty"`
	// Waiting is the package manager this rtk was installed with (winget,
	// Homebrew) when Latest is out but it has nothing newer than this rtk
	// yet, WaitingHas what it has: an upgrade through it would change
	// nothing, so the page offers none (#1025)
	Waiting    string `json:"waiting,omitempty"`
	WaitingHas string `json:"waitingHas,omitempty"`
	// Note is what an upgrade left to say: Homebrew's rtk behind rtk's
	// own release
	Note string `json:"note,omitempty"`
	// OffPath: rtk isn't on the PATH an agent started now gets, so its
	// hooks, which run rtk by name, do nothing (Pi's says "rtk binary not
	// found in PATH"). PathDir is where Put RTK on PATH makes it found — a
	// link to it made in that folder (PathLink), or (Windows) that folder,
	// rtk's own, added to the user's PATH; "" when magpie has nowhere
	PathDir  string     `json:"pathDir,omitempty"`
	PathLink bool       `json:"pathLink,omitempty"`
	OffPath  bool       `json:"offPath,omitempty"`
	Agents   []RTKAgent `json:"agents"`
	// WSL is the rtk of each WSL distro an agent listed lives in
	WSL []RTKDistro `json:"wsl,omitempty"`
	URL string      `json:"url"`
	// Install is the command Install RTK runs, shown before it is clicked
	Install string `json:"install,omitempty"`
	// Restart are the agents a change reached, to be restarted to see it
	Restart []string `json:"restart,omitempty"`
	Backup  string   `json:"backup,omitempty"`
}

var rtkMu sync.Mutex

// rtkPath is rtk's, "" when it isn't installed; one installed since magpie
// started may not be on its PATH yet, so where the installers put it is
// looked in too (Homebrew's are on it from the start: proc.UserPath).
// winget's is in its package folder, linked from WinGet\Links only when
// winget could make the link. Found there, it may not be on the PATH the
// agents get: see rtkReached.
func rtkPath() string {
	if p, err := proc.Look("rtk"); err == nil {
		return p
	}
	name, dirs := "rtk", append([]string{filepath.Join(home(), ".local", "bin")}, cargoBins()...)
	if runtime.GOOS == "windows" {
		winget := filepath.Join(appdir.Getenv("LOCALAPPDATA"), "Microsoft", "WinGet")
		name, dirs = "rtk.exe", append([]string{filepath.Join(winget, "Links")}, cargoBins()...)
		if appdir.Getenv("LOCALAPPDATA") != "" {
			pkgs, _ := filepath.Glob(filepath.Join(winget, "Packages", "rtk-ai.rtk_*"))
			dirs = append(dirs, pkgs...)
		}
	}
	for _, d := range dirs {
		if p := filepath.Join(d, name); exists(p) {
			return p
		}
	}
	return ""
}

func rtkRun(bin string, args ...string) (string, error) { return rtkRunEnv(bin, nil, args...) }

func rtkRunEnv(bin string, env []string, args ...string) (string, error) {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()
	cmd := proc.CommandContext(ctx, bin, args...)
	// rtk asks before a change it isn't told to make: nothing answers it
	cmd.Stdin = nil
	if env != nil {
		cmd.Env = append(os.Environ(), env...)
	}
	out, err := cmd.CombinedOutput()
	text := strings.TrimSpace(string(out))
	if err != nil {
		if text == "" {
			text = err.Error()
		}
		return text, fmt.Errorf("rtk %s: %s", strings.Join(args, " "), lastLines(text, 4))
	}
	return text, nil
}

func lastLines(s string, n int) string {
	ls := strings.Split(strings.TrimSpace(s), "\n")
	if len(ls) > n {
		ls = ls[len(ls)-n:]
	}
	return strings.Join(ls, " ")
}

// detected is the agents on this machine, as agent.Detected says; a var for
// tests. Detecting them probes a file or a command for every agent magpie
// knows of, which is a few hundred milliseconds, so it is asked once per read
// and not once per pass over the list (see ReadRTK).
var detected = agent.Detected

// rtkAgents are the agents on this machine rtk can be given to. They are as
// detected says, so a caller with a list already in hand passes it rather
// than have them detected again.
func rtkAgents(agents []*agent.Agent) []*agent.Agent {
	if agents == nil {
		agents = detected()
	}
	var out []*agent.Agent
	for _, a := range agents {
		sp, ok := rtkSpecs[rtkKind(a.ID)]
		// an uninstall that left the folder behind (#2254) isn't given rtk,
		// as the library gives it nothing (Targets); one with rtk's hook
		// still shows, so the hook can be taken out
		if ok && (!a.CLIMissing() || sp.has(a)) {
			out = append(out, a)
		}
	}
	return out
}

// ReadRTK says whether rtk is installed, what it saved, and which agents
// have it.
func ReadRTK() *RTKView {
	v := &RTKView{Agents: []RTKAgent{}, URL: RTKURL, Path: rtkPath()}
	if v.Path == "" {
		if c := rtkInstaller(); c != nil {
			v.Install = shown(c)
		}
	}
	// the agents are detected once and the two passes below share them
	agents := detected()
	for _, a := range rtkAgents(agents) {
		sp := rtkSpecs[rtkKind(a.ID)]
		ra := RTKAgent{ID: a.ID, Name: a.Name, Icon: a.Icon, WSL: a.WSL}
		// a stopped distro's files aren't opened: that starts it (#3896)
		if a.WSL != "" && !rtkWSLLive(a) {
			ra.Asleep = true
			v.Agents = append(v.Agents, ra)
			continue
		}
		ra.On = sp.has(a)
		if sp.blocked != nil {
			ra.Blocked = sp.blocked(a)
		}
		v.Agents = append(v.Agents, ra)
	}
	for _, a := range agents {
		if why, ok := rtkNoHook[rtkKind(a.ID)]; ok && !a.CLIMissing() {
			v.Agents = append(v.Agents, RTKAgent{ID: a.ID, Name: a.Name, Icon: a.Icon, Blocked: why, NoHook: true, WSL: a.WSL})
		}
	}
	v.WSL = rtkDistros(v.Agents)
	if v.Path == "" {
		return v
	}
	if !rtkReached() {
		v.OffPath = true
		v.PathDir, v.PathLink = rtkPathDir(v.Path)
	}
	if out, err := rtkRun(v.Path, "--version"); err == nil {
		v.Version = strings.TrimSpace(strings.TrimPrefix(out, "rtk"))
	}
	if c := upgraderOf(v.Path); c != nil {
		v.Upgrade, v.Admin = shown(c), rtkAdminFolder(c, v.Path)
	} else {
		if v.NoUpgrade = rtkNoUpgrade(v.Path); v.NoUpgrade == "cargo" {
			v.Manual = rtkCargoCmd
		}
	}
	v.Gain, v.Days, v.GainErr = rtkGain(v.Path)
	if runtime.GOOS == "windows" {
		for _, a := range v.Agents {
			if a.ID == "codex" && a.On {
				v.CodexSandbox = codexSandbox()
			}
		}
	}
	return v
}

// rtkGain is what rtk says it saved (rtk gain, from its history database:
// every command run through rtk on this machine by this user, from any
// agent or terminal, since its history began), and the days it saved it on,
// oldest first; nil and why when rtk didn't say, which the page shows rather
// than "nothing saved yet" (#741).
//
// Only its stdout is JSON: what rtk writes to stderr — a warning about a
// hook, a console code page, a corrupted table — went into the same buffer
// and made all of it unreadable, so it is read apart, and a line printed
// around the JSON object is passed over too.
func rtkGain(bin string) (*RTKGain, []RTKDay, string) {
	ctx, cancel := context.WithTimeout(context.Background(), 30*time.Second)
	defer cancel()
	// --daily adds the days to the summary (rtk 0.28 on)
	cmd := proc.CommandContext(ctx, bin, "gain", "--daily", "--format", "json")
	cmd.Stdin = nil
	var stdout, stderr bytes.Buffer
	cmd.Stdout, cmd.Stderr = &stdout, &stderr
	if err := cmd.Run(); err != nil {
		said := installerSaid(stderr.String()+"\n"+stdout.String(), 3)
		if said == "" {
			said = err.Error()
		}
		return nil, nil, "rtk gain: " + said
	}
	return parseGain(stdout.String())
}

func parseGain(out string) (*RTKGain, []RTKDay, string) {
	var g struct {
		Summary *struct {
			Commands int     `json:"total_commands"`
			Input    int64   `json:"total_input"`
			Saved    int64   `json:"total_saved"`
			Pct      float64 `json:"avg_savings_pct"`
		} `json:"summary"`
		Daily []struct {
			Date     string  `json:"date"`
			Commands int     `json:"commands"`
			Input    int64   `json:"input_tokens"`
			Saved    int64   `json:"saved_tokens"`
			Pct      float64 `json:"savings_pct"`
		} `json:"daily"`
	}
	i, j := strings.Index(out, "{"), strings.LastIndex(out, "}")
	if i < 0 || j < i || json.Unmarshal([]byte(out[i:j+1]), &g) != nil || g.Summary == nil {
		return nil, nil, strings.TrimSuffix("rtk gain printed no summary magpie can read: "+installerSaid(out, 2), ": ")
	}
	s := g.Summary
	if s.Commands == 0 {
		return nil, nil, ""
	}
	var days []RTKDay
	for _, d := range g.Daily {
		days = append(days, RTKDay{Date: d.Date, Commands: d.Commands, Input: d.Input, Saved: d.Saved, Pct: d.Pct})
	}
	slices.SortFunc(days, func(a, b RTKDay) int { return strings.Compare(a.Date, b.Date) })
	return &RTKGain{Commands: s.Commands, Input: s.Input, Saved: s.Saved, Pct: s.Pct}, days, ""
}

// codexSandbox is the Windows sandbox Codex runs its commands in, from its
// config.toml ([windows] sandbox, or the features it replaced): "elevated"
// runs them as Codex's own sandbox account (CodexSandboxOffline/Online,
// started with that account's profile), so the rtk its hook puts in front
// of them keeps its history in that account's AppData, not the user's;
// "unelevated" runs them with a token that can't write the user's. Either
// way rtk gain here doesn't count them. "" when Codex doesn't sandbox them.
// It is parsed again only when config.toml changes: one with a table for
// each of thousands of projects is ~0.2s of CPU to parse (#1665).
func codexSandbox() string {
	s, _ := filememo.Read("rtk codex sandbox", filepath.Join(codexDir(), "config.toml"), func(raw []byte) (string, error) {
		return codexSandboxIn(raw), nil
	})
	return s
}

// codexSandboxIn is codexSandbox of config.toml's bytes.
func codexSandboxIn(raw []byte) string {
	var c struct {
		SandboxMode string `toml:"sandbox_mode"`
		Windows     struct {
			Sandbox string `toml:"sandbox"`
		} `toml:"windows"`
		Features map[string]any `toml:"features"`
	}
	if toml.Unmarshal(raw, &c) != nil || c.SandboxMode == "danger-full-access" {
		return ""
	}
	switch {
	case c.Windows.Sandbox != "":
		if c.Windows.Sandbox == "elevated" || c.Windows.Sandbox == "unelevated" {
			return c.Windows.Sandbox
		}
	case c.Features["elevated_windows_sandbox"] == true:
		return "elevated"
	case c.Features["experimental_windows_sandbox"] == true, c.Features["enable_experimental_windows_sandbox"] == true:
		return "unelevated"
	}
	return ""
}

// shown is a command as the page shows it: a script's own line.
func shown(c []string) string {
	if c[0] == "sh" {
		return c[2]
	}
	if c[0] == rtkWindowsRelease {
		// magpie's own action, not a command line: name what it does
		// rather than the action and the path the user's rtk is at (#2006)
		return "rtk's own Windows release"
	}
	return strings.Join(c, " ")
}

// SetRTK gives rtk to an agent with rtk's own installer, or takes it away
// by taking out what that put in — which needs no rtk, so an agent left
// with the hook of an rtk since removed can be put right.
func SetRTK(id string, on bool) (*RTKView, error) {
	rtkMu.Lock()
	defer rtkMu.Unlock()
	var a *agent.Agent
	agents := detected()
	for _, x := range rtkAgents(agents) {
		if x.ID == id {
			a = x
		}
	}
	kind := rtkKind(id)
	sp, ok := rtkSpecs[kind]
	switch {
	case !ok && rtkNoHook[kind] != "":
		return nil, errors.New(rtkNoHook[kind])
	case !ok:
		return nil, fmt.Errorf("rtk has no hook for %s", id)
	case a == nil:
		return nil, fmt.Errorf("%s isn't installed", id)
	case a.WSL != "" && !rtkWSLLive(a):
		// nothing in it is read or run: that would start it (#3896)
		return nil, fmt.Errorf("WSL %s isn't running, and magpie doesn't start it to change RTK for %s: start the distro (open its terminal), then switch it again", a.WSL, a.Name)
	case sp.has(a) == on:
		return ReadRTK(), nil
	}
	if on && sp.blocked != nil {
		if why := sp.blocked(a); why != "" {
			return nil, errors.New(why)
		}
	}
	bin := ""
	if a.WSL != "" {
		// the hook runs in the distro, so it is the distro's rtk that is
		// run for it: a Windows rtk.exe is no path there
		if on {
			d := rtkDistroOf(a.WSL, true)
			if bin = d.Path; bin == "" {
				return nil, fmt.Errorf("RTK isn't installed in WSL %s — install it there first (magpie library rtk install %s)", a.WSL, a.WSL)
			}
		}
	} else if bin = rtkPath(); on && bin == "" {
		return nil, fmt.Errorf("rtk isn't installed — install it first (%s)", RTKURL)
	}
	b := newBackups()
	for _, p := range sp.files(a) {
		if err := b.keep(a.ID, p); err != nil {
			return nil, err
		}
	}
	if on {
		if err := rtkInstall(bin, a); err != nil {
			return nil, err
		}
	} else {
		if err := sp.remove(a); err != nil {
			return nil, fmt.Errorf("taking rtk out of %s: %w", a.Name, err)
		}
		if sp.has(a) {
			return nil, fmt.Errorf("rtk's hook is still in %s", a.Name)
		}
	}
	if b.dir != "" {
		pruneBackups()
	}
	v := ReadRTK()
	v.Restart, v.Backup = []string{a.ID}, b.dir
	return v, nil
}

func rtkInstall(bin string, a *agent.Agent) error {
	sp := rtkSpecs[rtkKind(a.ID)]
	if err := os.MkdirAll(sp.dir(a), 0o755); err != nil {
		return err
	}
	if a.WSL != "" {
		return rtkInstallWSL(bin, a, sp)
	}
	args := append([]string{"init", "-g"}, sp.flags...)
	if sp.patch {
		args = append(args, "--auto-patch")
	}
	var env []string
	if sp.withClaude {
		tmp, err := os.MkdirTemp("", "magpie-rtk-")
		if err != nil {
			return err
		}
		defer os.RemoveAll(tmp)
		env = []string{"CLAUDE_CONFIG_DIR=" + tmp}
	}
	if sp.env != nil {
		env = append(env, sp.env(a)...)
	}
	out, err := rtkRunEnv(bin, env, args...)
	if err != nil {
		return err
	}
	if !sp.has(a) {
		return fmt.Errorf("rtk's installer didn't add its hook to %s: %s", a.Name, lastLines(out, 3))
	}
	return nil
}

// rtkScript is rtk's own installer, which puts it in ~/.local/bin.
const rtkScript = "https://raw.githubusercontent.com/rtk-ai/rtk/refs/heads/master/install.sh"

// rtkInstaller is how rtk is installed here: with Homebrew when it has
// rtk's bottle for this computer, winget on Windows, else rtk's own
// script; nil when there's no way.
func rtkInstaller() []string {
	if runtime.GOOS == "windows" {
		if _, err := proc.Look("winget"); err == nil {
			return []string{"winget", "install", "--id", "rtk-ai.rtk", "--exact", "--silent", "--accept-package-agreements", "--accept-source-agreements", "--disable-interactivity"}
		}
		return nil
	}
	if brew, err := proc.Look("brew"); err == nil && brewBottled(brew) {
		return []string{"brew", "install", "rtk"}
	}
	if _, err := proc.Look("curl"); err == nil {
		return []string{"sh", "-c", "curl -fsSL " + rtkScript + " | sh"}
	}
	return nil
}

// brewBottled says whether Homebrew installs rtk on this computer from its
// bottle, a download of seconds. Without one, `brew install rtk` builds rtk
// from source, and first the Rust, LLVM and Python it builds with: hours,
// while Install RTK waits five minutes, so it never finished and was ended
// each time it was tried again (Scott__D on X). Homebrew bottles rtk for
// Apple silicon on the newest macOS versions only: not for an Intel Mac,
// nor for macOS 14 and older (brew there would install 19 formulae, rust
// and llvm among them, from source). brew info says which: "rtk: stable
// 1.1.0 (bottled)" only when brew would pour the bottle here. A brew that
// doesn't say, or doesn't answer, is not used: rtk's own script, which
// downloads rtk's release for this system, is.
//
// ReadRTK asks it on every read while rtk isn't installed, so the answer is
// kept for brewBottledFor, per brew.
var brewBottled = func(brew string) bool {
	bottled.Lock()
	defer bottled.Unlock()
	if bottled.brew == brew && time.Since(bottled.at) < brewBottledFor {
		return bottled.ok
	}
	ctx, cancel := context.WithTimeout(context.Background(), brewInfoWait)
	defer cancel()
	cmd := proc.CommandContext(ctx, brew, "info", "rtk")
	cmd.Stdin = nil
	cmd.Env = append(os.Environ(), "HOMEBREW_NO_AUTO_UPDATE=1", "HOMEBREW_NO_ENV_HINTS=1", "NONINTERACTIVE=1")
	out, err := cmd.Output()
	ok := err == nil && brewSaysBottled(string(out))
	bottled.brew, bottled.ok, bottled.at = brew, ok, time.Now()
	return ok
}

var bottled struct {
	sync.Mutex
	brew string
	ok   bool
	at   time.Time
}

const brewBottledFor = time.Hour

// brewInfoWait is how long brew info is given: it may first download
// Homebrew's formula list when its copy is old.
var brewInfoWait = 30 * time.Second

// brewSaysBottled reads brew info rtk's first line, "==> rtk: stable 1.1.0
// (bottled), HEAD".
func brewSaysBottled(out string) bool {
	for _, l := range strings.Split(ansiSeq.ReplaceAllString(out, ""), "\n") {
		if l = strings.TrimSpace(l); strings.HasPrefix(l, "==> rtk: ") {
			return strings.Contains(l, "(bottled)")
		}
	}
	return false
}

// InstallRTK installs rtk, when the user asks for it.
func InstallRTK() (*RTKView, error) {
	rtkMu.Lock()
	defer rtkMu.Unlock()
	if rtkPath() != "" {
		return ReadRTK(), nil
	}
	c := rtkInstaller()
	if c == nil {
		return nil, fmt.Errorf("no way to install rtk here — get it from %s", RTKURL)
	}
	out, err := runRTKInstaller(c, 5*time.Minute, "", "HOMEBREW_NO_AUTO_UPDATE=1")
	if err != nil {
		return nil, err
	}
	v := ReadRTK()
	if v.Path == "" {
		return nil, fmt.Errorf("%s ran, but rtk still isn't found: %s", strings.Join(c, " "), lastLines(string(out), 3))
	}
	return v, nil
}

// RTKTakes is the id of the agent q names when rtk can be given to it.
func RTKTakes(q string) (string, error) {
	a, err := agent.Find(q)
	if err != nil {
		return "", err
	}
	if why := rtkNoHook[rtkKind(a.ID)]; why != "" {
		return "", errors.New(why)
	}
	if _, ok := rtkSpecs[rtkKind(a.ID)]; !ok {
		var ids []string
		for id := range rtkSpecs {
			ids = append(ids, id)
		}
		slices.Sort(ids)
		return "", fmt.Errorf("rtk has no hook for %s (it has for %s)", a.Name, strings.Join(ids, ", "))
	}
	return a.ID, nil
}