Skip to content

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

25.4 KB
Raw Blame
package gui

import (
	"bytes"
	"cmp"
	"encoding/json"
	"errors"
	"maps"
	"net/http"
	"os"
	"reflect"
	"runtime"
	"runtime/debug"
	"slices"
	"strconv"
	"strings"
	"sync"
	"sync/atomic"
	"testing"
	"time"

	"github.com/yetone/magpie/internal/agent"
	"github.com/yetone/magpie/internal/filememo"
	"github.com/yetone/magpie/internal/proc"
	"github.com/yetone/magpie/internal/sessions"
	"github.com/yetone/magpie/internal/settings"
	"github.com/yetone/magpie/internal/usage"
)

// sessionJSON is a session with what the UI needs to draw its agent.
type sessionJSON struct {
	sessions.Session
	Name string `json:"name"`
	Icon string `json:"icon"`
	// Via: the models the gateway sent its calls to, at the reasoning
	// each was asked for, when it went through magpie
	Via []usage.Via `json:"via,omitempty"`
}

type sessionsJSON struct {
	Sessions []sessionJSON `json:"sessions"`
	// Terminal is set where magpie can open Terminal on the session: the
	// Mac app, not a browser tab that may be on another computer.
	Terminal bool     `json:"terminal"`
	Dirs     []string `json:"dirs"` // where they were read from
}

// gatewayExternal is a gateway session without its days: a list, a manage
// page and a detail (MergeExternal) never read them, and copying every
// session's days for each poll of an open Sessions page was ~1.8 GB in 4
// minutes over ~720k calls (#2776). The stats add them (gatewayDays).
func gatewayExternal(g usage.GatewaySession) sessions.ExternalSession {
	e := sessions.ExternalSession{Agent: g.Agent, ID: g.ID, Start: g.Start, Last: g.Last, Tokens: g.Tokens, Cost: g.Cost, Unpriced: g.Unpriced}
	e.Models = make([]sessions.ExternalModel, 0, len(g.Models))
	for _, m := range g.Models {
		e.Models = append(e.Models, sessions.ExternalModel{Model: m.Model, Tokens: m.Tokens, Cost: m.Cost, Priced: m.Priced})
	}
	return e
}

// gatewayDays is a gateway session's usage by day, as the stats count it.
func gatewayDays(g usage.GatewaySession) []sessions.ExternalDayUsage {
	out := make([]sessions.ExternalDayUsage, 0, len(g.Daily))
	for _, d := range g.Daily {
		out = append(out, sessions.ExternalDayUsage{Date: d.Date, Agent: d.Agent, Model: d.Model, Tokens: d.Tokens, Cost: d.Cost, Priced: d.Priced})
	}
	return out
}

// gatewayListed is a gateway session as a list shows it: titled by what it
// was first asked, when magpie recorded it, not by its ses_… id (YOU on
// Discord)
func gatewayListed(g usage.GatewaySession) sessions.ExternalSession {
	e := gatewayExternal(g)
	e.Title = sessions.GatewayTitle(g.Agent, g.ID)
	return e
}

func gatewaySession(g usage.GatewaySession) sessions.Session {
	return sessions.MergeExternal(nil, []sessions.ExternalSession{gatewayListed(g)})[0]
}

func sessionRoutes(mux *http.ServeMux, w Windows) {
	warmSessions()
	mux.HandleFunc("GET /api/sessions", func(rw http.ResponseWriter, r *http.Request) {
		// the list and the Codex threads' effort each list every session file
		defer sessions.OneListing()()
		n, _ := strconv.Atoi(r.URL.Query().Get("limit"))
		// The page draws a session count taken from every session
		// (statsFor's Overview) beside this list, so the list is read as
		// long as the count: at sessions.Limit the page said "238 sessions"
		// over a list that stopped at 200, and the agents whose sessions
		// were oldest fell off it whole — Codex had 121 and the list showed
		// 7. Only a caller that asks for a number of its own gets one. The
		// page draws this many rows in pages of its own (renderSessions).
		if n <= 0 {
			n = sessions.All
		}
		agents := map[string]*agent.Agent{}
		for _, a := range agent.Clients() {
			agents[a.ID] = a
		}
		out := sessionsJSON{Sessions: []sessionJSON{}, Terminal: runtime.GOOS == "darwin" && !isWeb(w),
			Dirs: []string{}}
		for _, d := range sessions.Dirs() {
			out.Dirs = append(out.Dirs, tilde(d))
		}
		list := sessions.List(sessions.All)
		nativeKeys := make(map[string]bool, len(list))
		for _, s := range list {
			for _, k := range sessions.GatewayKeys(s) {
				nativeKeys[k] = true
			}
			// a copy of its conversation is the agent's own too
			for _, id := range s.Copies {
				nativeKeys[s.Agent+"|"+id] = true
			}
		}
		gateway := listedGateway(usage.GatewaySessions(time.Time{}, nativeKeys))
		ext := make([]sessions.ExternalSession, 0, len(gateway))
		for _, g := range gateway {
			ext = append(ext, gatewayListed(g))
		}
		list = sessions.MergeExternal(list, ext)
		if len(list) > n {
			list = list[:n]
		}
		var modelEffort map[string][]sessions.ModelEffort
		for _, s := range list {
			if s.Agent == "codex" {
				modelEffort = usage.CodexModelEffort(usage.All)
				break
			}
		}
		for i := range list {
			addCodexModelEffort(&list[i], modelEffort)
		}
		since := time.Now()
		for _, s := range list {
			if !s.Start.IsZero() && s.Start.Before(since) {
				since = s.Start
			}
		}
		vias := usage.Vias(since.Add(-time.Minute))
		// made to size: up to sessions.All rows, grown by append each poll
		// was copied through every size on the way, ~140 MB of eight (#2278)
		out.Sessions = make([]sessionJSON, 0, len(list))
		for _, s := range list {
			j := sessionJSON{Session: s, Name: s.Agent, Icon: "generic", Via: viaOf(vias, s)}
			if a := agents[s.Agent]; a != nil {
				j.Name, j.Icon = a.SharedName(), a.Icon
			}
			j.Name = wslName(j.Name, s)
			j.Path = tilde(j.Path)
			out.Sessions = append(out.Sessions, j)
		}
		writeJSONRows(rw, r, "sessions", out.Sessions, struct {
			Terminal bool     `json:"terminal"`
			Dirs     []string `json:"dirs"`
		}{out.Terminal, out.Dirs})
	})
	// stats is every session's usage by day over the last ?days=N days
	// (every day when 0 or none), cut by agent, folder and model for the
	// page to filter; names are the agents' as the page shows them.
	mux.HandleFunc("GET /api/sessions/stats", func(rw http.ResponseWriter, r *http.Request) {
		defer sessions.ShareListing()()
		n, _ := strconv.Atoi(r.URL.Query().Get("days"))
		st, gen := statsForGen(n)
		names := map[string]string{}
		for _, a := range agent.Clients() {
			names[a.ID] = a.SharedName()
		}
		agents := map[string]string{}
		for _, d := range st.Days {
			for _, u := range d.Usage {
				agents[u.Agent] = cmp.Or(names[u.Agent], u.Agent)
			}
			for _, a := range d.Active {
				agents[a.Agent] = cmp.Or(names[a.Agent], a.Agent)
			}
		}
		// the page has this very answer: told so without encoding and
		// hashing a long history's ~6 MB of it again on every poll (#2278)
		statsTags.Lock()
		t, ok := statsTags.m[n]
		statsTags.Unlock()
		if ok && t.gen == gen && maps.Equal(t.agents, agents) && r.Header.Get("X-Magpie-Had") == t.tag {
			rw.Header().Set("X-Magpie-Tag", t.tag)
			rw.Header().Set("X-Magpie-Same", "1")
			rw.WriteHeader(http.StatusOK)
			return
		}
		tag := writeJSONSame(rw, r, struct {
			sessions.Stats
			Agents map[string]string `json:"agents"`
		}{st, agents})
		if tag != "" {
			statsTags.Lock()
			if statsTags.m == nil || len(statsTags.m) >= statsMemoMost {
				statsTags.m = map[int]statsTag{}
			}
			statsTags.m[n] = statsTag{gen, agents, tag}
			statsTags.Unlock()
		}
	})
	// overview sums up the range's sessions under the page's filters:
	// how many, what the middle one spent, how many each day, and the ones
	// that spent the most.
	mux.HandleFunc("GET /api/sessions/overview", func(rw http.ResponseWriter, r *http.Request) {
		defer sessions.ShareListing()()
		q := r.URL.Query()
		n, _ := strconv.Atoi(q.Get("days"))
		st := statsFor(n)
		out := st.Overview(q.Get("agent"), q.Get("model"), q.Get("cwd"), 8)
		period := usage.All
		if n > 0 {
			if p, ok := usage.RangeOf(st.From, st.To); ok {
				period = p
			}
		}
		needCodex := false
		for key, top := range out.Top {
			out.Top[key] = slices.Clone(top)
			for i := range out.Top[key] {
				if out.Top[key][i].Agent == "codex" {
					needCodex = true
				}
			}
		}
		if needCodex {
			modelEffort := usage.CodexModelEffort(period)
			for key, top := range out.Top {
				for i := range top {
					addCodexSummaryModelEffort(&top[i], modelEffort)
				}
				out.Top[key] = top
			}
		}
		writeJSON(rw, out)
	})
	// progress is how far the reading of the session files has got, for
	// the page to show while its first read takes a while.
	mux.HandleFunc("GET /api/sessions/progress", func(rw http.ResponseWriter, r *http.Request) {
		writeJSON(rw, sessions.Indexing())
	})
	// one is a session by its stats key, read however long ago it was at
	// work: the page's top sessions reach past the latest List reads.
	mux.HandleFunc("GET /api/sessions/one", func(rw http.ResponseWriter, r *http.Request) {
		key := r.URL.Query().Get("key")
		s, ok := sessions.Get(key)
		if !ok {
			if a, id, found := strings.Cut(key, ":"); found {
				if g, gok := usage.GatewaySessionByID(a, id, nil); gok {
					s = gatewaySession(g)
					ok = true
				}
			}
		}
		if !ok {
			rw.Header().Set("Content-Type", "application/json")
			rw.WriteHeader(http.StatusNotFound)
			_ = json.NewEncoder(rw).Encode(map[string]string{"error": "no such session"})
			return
		}
		if s.Agent == "codex" {
			addCodexModelEffort(&s, usage.CodexModelEffort(usage.All))
		}
		j := sessionJSON{Session: s, Name: s.Agent, Icon: "generic"}
		for _, a := range agent.Clients() {
			if a.ID == s.Agent {
				j.Name, j.Icon = a.SharedName(), a.Icon
			}
		}
		j.Name = wslName(j.Name, s)
		since := s.Start
		if since.IsZero() {
			since = s.Last
		}
		j.Via = viaOf(usage.Vias(since.Add(-time.Minute)), s)
		j.Path = tilde(j.Path)
		writeJSON(rw, j)
	})
	// transcript is what was said in a session, read from the agent's own
	// file (found from the session as listed, never a path from the page),
	// which is only read.
	mux.HandleFunc("GET /api/sessions/transcript", func(rw http.ResponseWriter, r *http.Request) {
		q := r.URL.Query()
		s, ok := sessions.Find(q.Get("agent"), q.Get("id"))
		if !ok {
			if _, found := usage.GatewaySessionByID(q.Get("agent"), q.Get("id"), nil); found {
				t, err := sessions.GatewayTranscript(q.Get("agent"), q.Get("id"))
				if err != nil {
					fail(rw, err)
					return
				}
				writeJSON(rw, t)
				return
			}
			fail(rw, errors.New("no such session"))
			return
		}
		// sub: one of its subagents, found among those the session lists
		// (#2261)
		read := sessions.TranscriptOf
		if sub := q.Get("sub"); sub != "" {
			read = func(s sessions.Session) (sessions.Transcript, error) { return sessions.SubagentTranscript(s, sub) }
		}
		t, err := read(s)
		if err != nil {
			fail(rw, err)
			return
		}
		writeJSON(rw, t)
	})
	// markdown is a session's whole conversation as a Markdown file (#1276),
	// read from the agent's own file as transcript is: to the browser that
	// asks (magpie web), which saves it itself, and, in the app, to
	// Downloads.
	mux.HandleFunc("GET /api/sessions/markdown", func(rw http.ResponseWriter, r *http.Request) {
		q := r.URL.Query()
		stem, md, err := sessionMarkdown(q.Get("agent"), q.Get("id"))
		if err != nil {
			fail(rw, err)
			return
		}
		rw.Header().Set("Content-Type", "text/markdown; charset=utf-8")
		rw.Header().Set("Content-Disposition", `attachment; filename="`+stem+`.md"`)
		rw.Write(md)
	})
	mux.HandleFunc("POST /api/sessions/export", func(rw http.ResponseWriter, r *http.Request) {
		q := r.URL.Query()
		stem, md, err := sessionMarkdown(q.Get("agent"), q.Get("id"))
		if err != nil {
			fail(rw, err)
			return
		}
		path, err := saveDownload(downloads(), stem, ".md", bytes.NewReader(md))
		if err != nil {
			fail(rw, err)
			return
		}
		writeJSON(rw, map[string]any{"path": tilde(path)})
	})
	// terminal opens Terminal on a session's resume command, or, with In, on
	// the command that carries it on in that other agent. The command is
	// made here from the session as listed, never taken from the page.
	mux.HandleFunc("POST /api/sessions/terminal", func(rw http.ResponseWriter, r *http.Request) {
		var in struct{ Agent, ID, In string }
		if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
			fail(rw, err)
			return
		}
		if runtime.GOOS != "darwin" || isWeb(w) {
			fail(rw, errors.New("opening Terminal is only for the Mac app"))
			return
		}
		s, ok := sessions.Find(in.Agent, in.ID)
		run := s.Resume
		if in.In != "" {
			run = ""
			for _, c := range s.Carry {
				if c.Agent == in.In {
					run = c.Command
				}
			}
		}
		if !ok || run == "" {
			fail(rw, errors.New("no such session"))
			return
		}
		if err := openTerminal(run, settings.Load().SessionTerminal); err != nil {
			fail(rw, err)
			return
		}
		rw.WriteHeader(http.StatusNoContent)
	})
	// carry converts a session for another agent (one its Carry offers with
	// Convert): a new session of that agent's, in its own folder, the
	// source only read. It runs only when the user picks the agent, never
	// on a listing. It answers with the line that opens the new one, and,
	// with Open, opens Terminal on it.
	mux.HandleFunc("POST /api/sessions/carry", func(rw http.ResponseWriter, r *http.Request) {
		var in struct {
			Agent, ID, To string
			Open          bool
		}
		if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
			fail(rw, err)
			return
		}
		if in.Open && (runtime.GOOS != "darwin" || isWeb(w)) {
			fail(rw, errors.New("opening Terminal is only for the Mac app"))
			return
		}
		s, ok := sessions.Find(in.Agent, in.ID)
		if !ok {
			fail(rw, errors.New("no such session"))
			return
		}
		c, err := sessions.CarryOver(s, in.To)
		if err != nil {
			fail(rw, err)
			return
		}
		if in.Open {
			if err := openTerminal(c.Command, settings.Load().SessionTerminal); err != nil {
				fail(rw, err)
				return
			}
		}
		writeJSON(rw, map[string]any{"agent": c.Agent, "id": c.ID, "command": c.Command})
	})
}

// sessionMarkdown is a session's conversation as Markdown, and the name its
// file is saved under: the session found as listed, never a path from the
// page. It is made whole before any of it is sent, so a file that can't be
// read is an error and not half a download.
//
// A session only magpie's gateway recorded is written from that record, as
// transcript reads it: the agent of one that reaches this magpie through a
// remote magpie ran on another machine, so there is no file of it here, and
// its download was a 400 "no such session" (akic404 on Discord).
func sessionMarkdown(agentID, id string) (stem string, md []byte, err error) {
	s, ok := sessions.Find(agentID, id)
	var t sessions.Transcript
	if !ok {
		g, found := usage.GatewaySessionByID(agentID, id, nil)
		if !found {
			return "", nil, errors.New("no such session")
		}
		if t, err = sessions.GatewayTranscript(agentID, id); err != nil {
			return "", nil, err
		}
		s = gatewaySession(g)
	}
	name := s.Agent
	for _, a := range agent.Clients() {
		if a.ID == s.Agent {
			name = a.SharedName()
		}
	}
	var b bytes.Buffer
	if ok {
		err = sessions.WriteMarkdown(&b, s, wslName(name, s))
	} else {
		err = sessions.WriteGatewayMarkdown(&b, s, name, t)
	}
	if err != nil {
		return "", nil, err
	}
	short := []rune(s.ID)
	if len(short) > 12 {
		short = short[:12]
	}
	safe := strings.Map(func(r rune) rune {
		if r >= 'a' && r <= 'z' || r >= 'A' && r <= 'Z' || r >= '0' && r <= '9' || r == '-' || r == '_' {
			return r
		}
		return '-'
	}, s.Agent+"-"+string(short))
	return "magpie-session-" + safe, b.Bytes(), nil
}

// wslName is an agent's name for a session it ran in a WSL distro, as the
// agent there is named (Claude Code · WSL Ubuntu); its own name otherwise.
func wslName(name string, s sessions.Session) string {
	if s.WSL == "" {
		return name
	}
	return name + " · WSL " + s.WSL
}

// statsFor is sessions.StatsFor for a range, kept: the page asks for the
// stats and the overview one after the other, and for the same range again
// each time it is shown. What was read is answered at once; when it is more
// than a few seconds old it is read again behind, for the next ask.
var statsMemo struct {
	sync.Mutex
	m    map[int]*statsKept
	asks uint64
}

type statsKept struct {
	at   time.Time
	st   sessions.Stats
	gen  uint64 // st's, new only when a read found st changed
	busy bool
	// used is the memo's ask count when this range was last asked: a count,
	// not a clock, since Windows' clock can give two asks the same time.
	used uint64
}

// statsMemoMost is how many distinct ?days values the memo keeps: each one is
// a whole sessions.Stats, and ?days takes any number a caller sends, so the
// least recently asked one is let go when a new value comes past it.
const statsMemoMost = 8

// statsGen numbers each Stats the memo keeps, across memos: an answer's
// tag is known by it (statsTags).
var statsGen atomic.Uint64

// statsTags is the tag of the stats answer last sent for each ?days, the
// Stats it was made from known by its gen.
var statsTags struct {
	sync.Mutex
	m map[int]statsTag
}

type statsTag struct {
	gen    uint64
	agents map[string]string
	tag    string
}

// sameStats is whether a and b would be sent the same: a read again
// behind finds the same stats most times, and keeping a's gen spares the
// page's next ask the encoding.
func sameStats(a, b sessions.Stats) bool {
	return a.From == b.From && a.To == b.To && slices.Equal(a.Keys, b.Keys) && reflect.DeepEqual(a.Days, b.Days)
}

func statsFor(days int) sessions.Stats {
	st, _ := statsForGen(days)
	return st
}

func statsForGen(days int) (sessions.Stats, uint64) {
	days = max(0, days)
	statsMemo.Lock()
	if k := statsMemo.m[days]; k != nil {
		statsMemo.asks++
		k.used = statsMemo.asks
		if !k.busy && time.Since(k.at) > 10*time.Second {
			// every range kept that is as old is read again with it, in
			// one pass: the page asks for 7, 30 and every day, and each
			// read alone listed and summed every session file (#2278)
			var ranges []int
			var kept []*statsKept
			for d, o := range statsMemo.m {
				if !o.busy && time.Since(o.at) > 10*time.Second {
					o.busy = true
					ranges, kept = append(ranges, d), append(kept, o)
				}
			}
			// read beside the page's own reads: with their listing of
			// the session files, and handed back once they all rest
			shared, rest := sessions.ShareListing(), readingPage()
			go func() {
				defer rest()
				defer shared()
				sts := combinedSessionStatsAll(ranges)
				statsMemo.Lock()
				for i, o := range kept {
					if !sameStats(o.st, sts[i]) {
						o.st, o.gen = sts[i], statsGen.Add(1)
					}
					o.at, o.busy = time.Now(), false
				}
				statsMemo.Unlock()
			}()
		}
		st, gen := k.st, k.gen
		statsMemo.Unlock()
		return st, gen
	}
	statsMemo.Unlock()
	st, gen := combinedSessionStats(days), statsGen.Add(1)
	statsMemo.Lock()
	if statsMemo.m == nil {
		statsMemo.m = map[int]*statsKept{}
	}
	if statsMemo.m[days] == nil {
		if len(statsMemo.m) >= statsMemoMost {
			oldest := -1
			for d, k := range statsMemo.m {
				if oldest == -1 || k.used < statsMemo.m[oldest].used {
					oldest = d
				}
			}
			delete(statsMemo.m, oldest)
		}
		statsMemo.asks++
		statsMemo.m[days] = &statsKept{at: time.Now(), st: st, gen: gen, used: statsMemo.asks}
	}
	statsMemo.Unlock()
	return st, gen
}

func combinedSessionStats(days int) sessions.Stats {
	return combinedSessionStatsAll([]int{days})[0]
}

// combinedSessionStatsAll is combinedSessionStats for each of days, the
// session files read once for all of them.
func combinedSessionStatsAll(days []int) []sessions.Stats {
	sts, nativeKeys := sessions.StatsAndNativeAll(days)
	for i := range sts {
		sts[i] = withGatewaySessions(sts[i], days[i], nativeKeys)
	}
	return sts
}

func withGatewaySessions(st sessions.Stats, days int, nativeKeys map[string]bool) sessions.Stats {
	var since time.Time
	if days > 0 && st.From != "" {
		since, _ = time.ParseInLocation(time.DateOnly, st.From, time.Local)
	}
	gs, gd := usage.GatewaySessionWindowExcept(since, nativeKeys)
	ext := make([]sessions.ExternalSession, 0, len(gs))
	for _, g := range gs {
		e := gatewayListed(g)
		e.Daily = gatewayDays(g)
		ext = append(ext, e)
	}
	daily := make([]sessions.ExternalDayUsage, 0, len(gd))
	for _, d := range gd {
		daily = append(daily, sessions.ExternalDayUsage{Date: d.Date, Agent: d.Agent, Model: d.Model, Tokens: d.Tokens, Cost: d.Cost, Priced: d.Priced})
	}
	return sessions.MergeExternalStats(st, daily, ext)
}

// warmSessions reads every session file once magpie is up, so the Sessions
// page opens on the kept index and not on a first read of them all. Usage ›
// Requests' whole history is read after it, not beside it on the disk: a
// first All parsing 12k sessions kept that page a skeleton for 40 s.
// Once a process: the app's page served to a browser (apppage.go) is a
// second Handler beside the window's.
func warmSessions() {
	if testing.Testing() {
		return
	}
	warmOnce.Do(warmStart)
}

var warmOnce sync.Once

func warmStart() {
	go func() {
		// a fresh install reads no agent's sessions until asked; one
		// that read them before keeps reading them (decided once)
		sessions.SettleReads()
		time.Sleep(3 * time.Second)
		// with few readers, as nobody waits on it yet: after an update
		// that reads every file again, it held every core (#1665)
		sessions.Warm(func() { warmUp(warmSteps()...) })
	}()
}

// warmSteps are the reads the warm-up makes before any page asks for them.
// The last is Codex's per-thread effort, when there are Codex sessions: a
// first Codex page after a start read it from the whole ledger while it
// waited (#2776), and every later ask is answered from what it kept.
func warmSteps() []func() {
	return []func(){
		func() { statsFor(0) },
		func() { statsFor(30) },
		func() { underTightGC(func() { usage.QueryPage(usage.All, usage.Filter{}, 0, 50) }) },
		func() {
			if slices.ContainsFunc(statsFor(0).Keys, func(k string) bool { return strings.HasPrefix(k, "codex:") }) {
				underTightGC(warmCodexEffort)
			}
		},
	}
}

// warmCodexEffort reads what the Sessions page's Codex rows ask for.
var warmCodexEffort = func() { usage.CodexModelEffort(usage.All) }

// warmUp runs the warm-up's reads, then hands what they threw away back to
// the system at once. Reading a long history allocates many times what it
// keeps (a 13k-session Codex and Claude Code history: ~830 MB allocated to
// keep ~80 MB of indexes), and Go's scavenger returns those pages only over
// the next minutes: a magpie that had just started read ~470 MB for its
// first two minutes at rest.
func warmUp(steps ...func()) {
	// each file read looked at once a second, not for each session or row
	// that asks: an empty sandbox's warm-up looked at settings.json ~300
	// times on Windows (#1665); a write still reads the disk (edit.Read)
	defer filememo.Hold()()
	for _, step := range steps {
		step()
	}
	debug.FreeOSMemory()
}

// underTightGC runs fn letting the heap grow by a quarter of what it holds
// before a collection, not Go's default of all of it, and then puts back
// what was set; a GOGC the user set lower, or off, is kept. The usage
// page's read of the whole history holds every row of it at once (~270 MB
// live for 390k calls), and a cold start that rests at ~200 MB peaked at
// 555–587 MB in Activity Monitor there; under it, 410–438 MB. That read
// and Codex's effort, which reads the whole ledger again while the page
// still holds its rows, run under it: the warm-up as a whole did too for
// ~11 s more CPU.
//
// It sets no memory limit. It held the memory Go asked of the system to
// what it held when fn began, and a cold start then reached the limit
// with the heap all live: from ~11 s to ~24 s it collected every ~160 ms,
// a core's worth, 3:39 of CPU in its first 60 s for 390k calls and 1166
// collections. Without it, 2:03–2:06 and 618, and the footprint's peak
// the same, 835–863 MB against 855 (#2278).
func underTightGC(fn func()) {
	defer tightenGC()()
	fn()
}

// tightGC is what the reads under a tight GC hold: the first to begin sets
// it, and the last to end puts back what was set before it. Each read
// putting back what it found let two at once leave GOGC at 25 for good,
// when the first to begin ended before the second.
var tightGC struct {
	sync.Mutex
	n   int // reads under it
	was int // GOGC before the first
}

// tightenGC begins a read under a tight GC; undo ends it.
func tightenGC() (undo func()) {
	tightGC.Lock()
	defer tightGC.Unlock()
	if tightGC.n == 0 {
		was := debug.SetGCPercent(tightGCPercent)
		if was < tightGCPercent {
			debug.SetGCPercent(was)
		}
		tightGC.was = was
	}
	tightGC.n++
	return sync.OnceFunc(func() {
		tightGC.Lock()
		defer tightGC.Unlock()
		if tightGC.n--; tightGC.n == 0 {
			debug.SetGCPercent(tightGC.was)
		}
	})
}

const tightGCPercent = 25

// openTerminal runs a command in the chosen Mac terminal through a .command
// file, as it would open from Finder: no Automation consent.
// The shell is left open when the agent quits.
func openTerminal(command, choice string) error {
	var found terminalDiscovery
	if choice != terminalBundleID {
		var err error
		// the system default falls back to Terminal when nothing is found
		if found, err = discoverTerminals(); err != nil && choice != "" && choice != "system" {
			return err
		}
	}
	args, err := terminalOpenArgs(choice, found)
	if err != nil {
		return err
	}
	f, err := os.CreateTemp("", "magpie-resume-*.command")
	if err != nil {
		return err
	}
	script := "#!/bin/sh\n" + command + "\nexec \"${SHELL:-/bin/zsh}\" -l\n"
	_, err = f.WriteString(script)
	if cerr := f.Close(); err == nil {
		err = cerr
	}
	if err == nil {
		err = os.Chmod(f.Name(), 0o700)
	}
	if err != nil {
		os.Remove(f.Name())
		return err
	}
	args = append(args, f.Name())
	if err := proc.Command("open", args...).Run(); err != nil {
		os.Remove(f.Name())
		return err
	}
	// Terminal has read it long before
	time.AfterFunc(time.Minute, func() { os.Remove(f.Name()) })
	return nil
}

// viaOf is what the gateway sent a session's calls to, under any key its
// gateway record can carry (sessions.GatewayKeys: Raft's Pi says it is Pi).
func viaOf(x usage.ViaIndex, s sessions.Session) []usage.Via {
	for _, k := range sessions.GatewayKeys(s) {
		if v := x.Of(k); v != nil {
			return v
		}
	}
	return nil
}