Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
package agent
import (
"crypto/sha256"
"encoding/hex"
"encoding/json"
"os"
"path/filepath"
"runtime"
"slices"
"strconv"
"strings"
"time"
"github.com/yetone/magpie/internal/edit"
"github.com/yetone/magpie/internal/provider"
"github.com/yetone/magpie/internal/settings"
)
// What the Agents page says beside an agent's 「接入」 switch (the owner's
// design): before it is on, what the agent runs on now — its own
// subscription, sign-in or providers — so the user can tell what turning
// it on touches; once on, whether copies of it already running still have
// the list they started with.
// Source is what an agent not connected to magpie runs on now: "sub" (a
// Claude subscription), "chatgpt" (a ChatGPT sign-in), "key" (an API key
// of its own), "providers:N" (N providers of its own); "" when unknown.
//
// With account discovery off (#1535) no sign-in is read for it: Claude
// Code's account in .claude.json, Codex's auth.json and OpenCode's are
// left alone, and only what the agent's own settings say is told.
func (a *Agent) Source() string {
if a.WSL != "" || a.Path == "" {
return ""
}
dir := filepath.Dir(a.Path)
signIns := !settings.AccountDiscoveryOff()
switch a.ID {
case "claude":
// signed in to claude.ai: ~/.claude.json (or the one in
// CLAUDE_CONFIG_DIR) has the account
for _, p := range []string{filepath.Join(dir, ".claude.json"), filepath.Join(filepath.Dir(dir), ".claude.json")} {
if !signIns {
break
}
if v, _ := edit.GetJSON(p, "oauthAccount.accountUuid"); v != "" {
return "sub"
}
}
if v, _ := edit.GetJSON(a.Path, "env.ANTHROPIC_API_KEY"); v != "" {
return "key"
}
if v, _ := edit.GetJSON(a.Path, "apiKeyHelper"); v != "" {
return "key"
}
case "codex":
if !signIns {
break
}
if codexChatGPT(dir) {
return "chatgpt"
}
var k struct {
Key string `json:"OPENAI_API_KEY"`
}
if b, ok := provider.CodexSignIn(dir); ok && json.Unmarshal(b, &k) == nil && k.Key != "" {
return "key"
}
case "opencode", "mimocode", "deveco":
// the providers in its config, and those signed in through it
n := map[string]bool{}
var cfg map[string]json.RawMessage
if v, _ := edit.GetJSON(a.Path, "provider"); json.Unmarshal([]byte(v), &cfg) == nil {
for k := range cfg {
n[k] = true
}
}
home, _ := os.UserHomeDir()
var auth map[string]json.RawMessage
if b, err := readOwnAuth(filepath.Join(home, ".local", "share", a.ID, "auth.json")); err == nil && json.Unmarshal(b, &auth) == nil {
for k := range auth {
n[k] = true
}
}
delete(n, magpieID)
if len(n) > 0 {
return "providers:" + strconv.Itoa(len(n))
}
}
return ""
}
// FailoverSaid is, for an agent not connected whose requests still go
// through magpie for account failover alone (FailingOver), what the CLI
// and the TUI say of it, the Agents page's line in words of their own:
// why it goes through magpie, and what turns that off (#1385). "" when it
// doesn't.
func (a *Agent) FailoverSaid() string {
if a.FailingOver == nil || !a.FailingOver() {
return ""
}
return "not connected · goes through magpie only to fail over to your other ChatGPT accounts; tick Only switch Codex's sign-in under Providers › Codex (magpie accounts switch-only codex on), or switch them off, to stop it"
}
// startsWith is, for an agent that reads magpie's models only as it
// starts, how to find its processes (patterns for pgrep -f), the files it
// reads them from, and the part of those files magpie writes for it. The
// files' times alone don't say when magpie changed that part: the agent
// writes the same files (Codex keeps each project's trust, a notice seen,
// the model picked in its app in config.toml), and a copy started before
// such a write has magpie's list all the same (#729).
func (a *Agent) startsWith() (pats []string, files []string, reads func() string) {
switch a.ID {
case "codex":
list := filepath.Join(filepath.Dir(a.Path), "magpie-models.json")
// the list written for the Codex app beside the sign-in (deskList)
desk := filepath.Join(filepath.Dir(a.Path), "magpie-desktop-models.json")
return []string{`(^|/)codex( |$)`}, []string{a.Path, list, desk}, func() string {
var b strings.Builder
for _, k := range []string{"model_provider", "model_catalog_json", "openai_base_url"} {
v, _ := edit.GetTOMLTop(a.Path, k)
b.WriteString(k + "=" + v + "\n")
}
t, _ := edit.GetTOMLTable(a.Path, "model_providers."+magpieID)
j, _ := json.Marshal(t)
b.Write(j)
c, _ := os.ReadFile(list)
b.Write(c)
d, _ := os.ReadFile(desk)
b.Write(d)
return b.String()
}
case "claude":
return []string{`(^|/)claude( |$)`}, []string{a.Path}, func() string {
env, _ := edit.GetJSON(a.Path, "env")
model, _ := edit.GetJSON(a.Path, "model")
return env + "\n" + model
}
}
return nil, nil, nil
}
// runningProc is a process found for an agent: how long it has run, and
// its command line.
type runningProc struct {
up time.Duration
cmd string
}
// running lists the processes a pgrep -f pattern matches. A var so tests
// can say.
var running = listRunning
// changedAt is when magpie last changed what the agent reads at start. It
// is kept in the stash with a digest of what that was, so neither the
// agent's own writes to the same files nor magpie starting again move it;
// a change first seen is put at the files' latest write, or at now when
// no file was written since the last one. Zero when the files aren't
// there.
func (a *Agent) changedAt(files []string, reads func() string) time.Time {
var mod time.Time
for _, f := range files {
if st, err := os.Stat(f); err == nil && st.ModTime().After(mod) {
mod = st.ModTime()
}
}
if mod.IsZero() {
return mod
}
sum := sha256.Sum256([]byte(reads()))
digest := hex.EncodeToString(sum[:8])
key := a.ID + ".started"
was, at, ok := strings.Cut(stashLoad()[key], " ")
n, err := strconv.ParseInt(at, 10, 64)
if ok && err == nil && was == digest {
return time.Unix(0, n)
}
// a change no file's time shows (Claude Desktop's models are the
// gateway's, not a file's) is put at when it is first seen
if ok && err == nil && !mod.After(time.Unix(0, n)) {
mod = time.Now()
}
stash(map[string]string{key: digest + " " + strconv.FormatInt(mod.UnixNano(), 10)})
return mod
}
// Stale is how many copies of the agent are running that started before
// magpie last changed what it reads at start: they still have the list
// they started with until reopened. On Windows only the Codex daemon is
// told.
func (a *Agent) Stale() int { return len(a.StaleCopies()) }
// StaleCopy is a copy of an agent still running on the list it started
// with: what kind of copy it is, which says how it is reopened, and when
// it started.
type StaleCopy struct {
// Kind, for Codex: "app" (the ChatGPT or Codex desktop app, its
// app-server and helpers), "ide" (an editor extension's), "daemon"
// (the background app-server the CLI leaves running), "helper" (a
// subcommand the daemon spawns beside itself, no copy to reopen) or
// "cli"; "" for other agents; "embedded" is another app's own Codex,
// named by App
Kind string `json:"kind,omitempty"`
App string `json:"app,omitempty"`
// Bundle is the desktop app's own, for "app": what the row's Restart
// quits and opens again
Bundle string `json:"bundle,omitempty"`
Since time.Time `json:"since"`
}
// StaleCopies are the copies Stale counts. Reopening one kind doesn't end
// another: on macOS the Codex app keeps running, its app-server with it,
// when its window is closed (its window-all-closed doesn't quit a packaged
// app on darwin), an editor's Codex runs until the editor's window is
// reloaded, and the CLI's managed daemon runs on with ppid 1 until it is
// restarted itself. So each is told apart for the row to say which one is
// left. One app's processes (its app-server, its exec-server) are one copy.
// One run from another home's agent dir (an app-server daemon Codex left
// running for a CODEX_HOME of its own, under its packages) reads other
// files, and isn't counted.
func (a *Agent) StaleCopies() []StaleCopy {
pats, files, reads := a.startsWith()
// Windows lists its processes slowly and without their start: only
// the Codex daemon, as KeepCodexDaemonCurrent last found it
if a.ID == "codex" && a.WSL == "" && runtime.GOOS == "windows" {
return codexDaemonBehind()
}
if len(pats) == 0 || a.WSL != "" || runtime.GOOS == "windows" {
return nil
}
changed := a.changedAt(files, reads)
if changed.IsZero() {
return nil
}
dir := filepath.Dir(a.Path)
others := "/" + filepath.Base(dir) + "/"
var out []StaleCopy
apps := map[string]int{}
for _, pat := range pats {
for _, p := range running(pat) {
if strings.Contains(p.cmd, others) && !strings.Contains(p.cmd, dir+"/") {
continue
}
since := time.Now().Add(-p.up)
if !since.Before(changed.Add(-time.Second)) {
continue
}
c := StaleCopy{Since: since}
if a.ID == "codex" {
var app string
c.Kind, app = codexCopyKind(p.cmd)
if c.Kind == "helper" {
// a daemon subcommand's helper reads no list, a
// restart of the daemon doesn't end it, and there
// is no Codex to quit (#1461)
continue
}
switch c.Kind {
case "embedded":
c.App = app
case "app":
c.Bundle = app
}
if app != "" {
if i, ok := apps[app]; ok {
if since.Before(out[i].Since) {
out[i].Since = since
}
continue
}
apps[app] = len(out)
}
}
out = append(out, c)
}
}
return out
}
// codexCopyKind tells what runs a Codex process from its command line, and
// for one of a desktop app the app's bundle.
func codexCopyKind(cmd string) (kind, app string) {
exe := cmd
if i := strings.Index(cmd, " -"); i > 0 {
exe = cmd[:i]
}
switch {
case slices.ContainsFunc(strings.Fields(cmd), func(f string) bool {
return f == "--managed-daemon" || strings.HasPrefix(f, "--managed-daemon=")
}):
return "daemon", ""
case strings.Contains(exe, "/extensions/"):
return "ide", ""
case strings.Contains(exe, ".app/Contents/"):
// the outermost bundle: ChatGPT.app's codex runs from a
// CodexCLI.app inside it
return "app", exe[:strings.Index(exe, ".app/")+len(".app")]
case daemonHelper(cmd):
// a subcommand the managed daemon spawns beside itself (codex
// app-server daemon pid-update-loop): long-lived, reads no list,
// and outlives a daemon restart (#1461)
return "helper", ""
case slices.Contains(strings.Fields(cmd), "app-server"):
// an app that ships a Codex of its own and talks to its
// app-server (Agents Anywhere's connector, from its folder in
// Application Support): reopening that app ends it. A codex
// installed there by a version manager (fnm) and run in a
// terminal is no app-server, and stays "cli".
for _, under := range []string{"/Library/Application Support/", "/.local/share/"} {
if _, rest, ok := strings.Cut(exe, under); ok {
if name, _, ok := strings.Cut(rest, "/"); ok && name != "" {
return "embedded", name
}
}
}
}
return "cli", ""
}
// daemonHelper says the command line is a subcommand the managed daemon
// spawns beside itself: app-server daemon <sub> (pid-update-loop, …). The
// daemon itself carries --managed-daemon and is told apart above.
func daemonHelper(cmd string) bool {
f := strings.Fields(cmd)
for i, s := range f {
if s == "app-server" && i+2 < len(f) && f[i+1] == "daemon" {
return true
}
}
return false
}
// elapsed reads ps's etime, [[dd-]hh:]mm:ss.
func elapsed(s string) (time.Duration, bool) {
s = strings.TrimSpace(s)
if s == "" {
return 0, false
}
var days int
if d, rest, ok := strings.Cut(s, "-"); ok {
n, err := strconv.Atoi(d)
if err != nil {
return 0, false
}
days, s = n, rest
}
parts := strings.Split(s, ":")
if len(parts) < 2 || len(parts) > 3 {
return 0, false
}
secs := 0
for _, p := range parts {
n, err := strconv.Atoi(p)
if err != nil {
return 0, false
}
secs = secs*60 + n
}
return time.Duration(days)*24*time.Hour + time.Duration(secs)*time.Second, true
}