Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
// Package gui hosts the desktop app: a tray panel and a regular window that
// share one small web UI. The UI talks to Go over a tiny JSON API served by
// the same handler that serves the static assets, so no binding generator or
// bundler is involved.
package gui
import (
"bytes"
"cmp"
"context"
"crypto/sha256"
"embed"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io/fs"
"maps"
"mime"
"net/http"
"os"
"path"
"path/filepath"
"regexp"
"runtime"
"slices"
"strconv"
"strings"
"sync"
"time"
"github.com/yetone/magpie/internal/access"
"github.com/yetone/magpie/internal/agent"
"github.com/yetone/magpie/internal/autostart"
"github.com/yetone/magpie/internal/catalog"
"github.com/yetone/magpie/internal/filememo"
"github.com/yetone/magpie/internal/fonts"
"github.com/yetone/magpie/internal/fx"
"github.com/yetone/magpie/internal/gateway"
"github.com/yetone/magpie/internal/ghtoken"
"github.com/yetone/magpie/internal/lastgood"
"github.com/yetone/magpie/internal/library"
"github.com/yetone/magpie/internal/mcpauth"
"github.com/yetone/magpie/internal/middleware"
"github.com/yetone/magpie/internal/netproxy"
"github.com/yetone/magpie/internal/notices"
"github.com/yetone/magpie/internal/plugin"
"github.com/yetone/magpie/internal/profile"
"github.com/yetone/magpie/internal/provider"
"github.com/yetone/magpie/internal/redact"
"github.com/yetone/magpie/internal/sessions"
"github.com/yetone/magpie/internal/settings"
"github.com/yetone/magpie/internal/update"
"github.com/yetone/magpie/internal/usage"
)
// cliBehind is the terminal's magpie command when it's a copied file rather
// than the installer's link — a copy can't follow updates (#531's lesson) —
// told once, and only until the user dismisses it for this version. The
// check is a bare Lstat: telling a *stale* copy from a current one would
// mean running the old binary, and `magpie version` isn't read-only — it
// migrates the user's settings first, with the old build's migrations. Only
// `magpie update`, which the user started, reads versions (update.StaleCLI).
// "" when the command is the link or absent, this isn't the Mac, or the
// advice was dismissed for this version.
func cliBehind() string {
cliBehindOnce.Do(func() {
cli := update.CopiedCLI()
if cli == "" {
return
}
if cliQuiet() {
return
}
cliBehindMu.Lock()
cliBehindVal = tilde(cli)
cliBehindMu.Unlock()
})
cliBehindMu.Lock()
defer cliBehindMu.Unlock()
return cliBehindVal
}
// cliQuiet is whether the advice was dismissed for this version; the
// dismiss is kept per version, so the next app update asks once more.
// cliQuietFile holds the version it was dismissed at.
const cliQuietFile = "cli-behind-quiet"
func cliQuiet() bool {
b, err := os.ReadFile(filepath.Join(settings.Dir(), cliQuietFile))
return err == nil && strings.TrimSpace(string(b)) == Version
}
// setCLIQuiet dismisses the advice until the next version.
func setCLIQuiet() error {
if err := os.MkdirAll(settings.Dir(), 0o755); err != nil {
return err
}
return os.WriteFile(filepath.Join(settings.Dir(), cliQuietFile), []byte(Version+"\n"), 0o644)
}
// cliBehindRoutes serves the advice's "Hide until the next version".
func cliBehindRoutes(mux *http.ServeMux) {
mux.HandleFunc("POST /api/cli-behind/quiet", func(rw http.ResponseWriter, r *http.Request) {
if err := setCLIQuiet(); err != nil {
fail(rw, err)
return
}
cliBehindMu.Lock()
cliBehindVal = "" // kept away until the next version; the Once already ran
cliBehindMu.Unlock()
rw.WriteHeader(http.StatusNoContent)
})
// Settings' Command line: what `magpie` runs in each shell, and this
// app's put there when asked (update.AddCLI); shell names the one whose
// profile gets ~/.local/bin
mux.HandleFunc("GET /api/cli", func(rw http.ResponseWriter, r *http.Request) {
writeJSON(rw, update.ReadCLI())
})
// Settings › About's Open-source licenses: the notices this binary
// carries (notices.Text, THIRD_PARTY_NOTICES)
mux.HandleFunc("GET /api/notices", func(rw http.ResponseWriter, r *http.Request) {
writeJSON(rw, map[string]string{"text": notices.Text})
})
mux.HandleFunc("POST /api/cli", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Shell string `json:"shell"`
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
v, err := update.AddCLI(in.Shell)
if err != nil {
fail(rw, err)
return
}
writeJSON(rw, v)
})
}
var cliBehindOnce = new(sync.Once) // a var so tests can ask again
var cliBehindMu sync.Mutex // the dismiss handler writes cliBehindVal while state() reads it on other goroutines
var cliBehindVal string
// Version is the build's version string, shown in Settings.
var Version = "dev"
//go:embed assets
var assets embed.FS
// Windows is what the API needs from the host application.
type Windows interface {
HidePanel()
// ShowMain brings the window up, on the named tab when view is set.
ShowMain(view string)
Quit()
// OpenURL hands a link to the system browser. The error is the browser's
// not starting, which a sign-in shows with its link (#2043).
OpenURL(url string) error
// OpenFolder shows a folder in the system file manager.
OpenFolder(path string) error
// ChooseFolder asks for a folder in the system's picker: "" when the
// user cancels it.
ChooseFolder(title string) (string, error)
// Copy puts text on the system clipboard, which the page's own
// navigator.clipboard can't always reach from inside the app.
Copy(text string) bool
// FitPanel asks for the panel to be tall enough for its content.
FitPanel(height int, g Glide)
// TintPanel paints the panel's tint behind the page, where the system
// keeps up with the panel's size; false when it can't, for the page to
// go on painting it itself.
TintPanel(rgba [4]uint8, ms int) bool
// TintTitleBar paints the window's title bar the page's colour, where
// the system draws one (Windows); false where there is none to paint.
TintTitleBar(rgba [4]uint8, dark bool) bool
// SetTextSize zooms the window's and the panel's pages to percent
// (settings.TextSizes), the panel's size with them.
SetTextSize(percent int)
}
type fieldJSON struct {
Key string `json:"key"`
Label string `json:"label"`
Value string `json:"value"`
Options []agent.Option `json:"options"`
}
type agentJSON struct {
ID string `json:"id"`
Name string `json:"name"`
Icon string `json:"icon"`
Path string `json:"path"`
Fields []fieldJSON `json:"fields"`
// Drift: its config no longer does what magpie set, and how to set it again
Drift *agent.Drift `json:"drift,omitempty"`
// Wired: magpie is in its config, which its menu's Disconnect takes out
Wired bool `json:"wired,omitempty"`
// Import: an app that takes magpie by its own link (Cindy), and
// whether it has magpie already; omitted when the app has no status reader
Import string `json:"import,omitempty"`
Added *bool `json:"added,omitempty"`
// Launch: the command that starts an agent taking the gateway only
// from its environment (agy) on magpie, to copy
Launch string `json:"launch,omitempty"`
// Typed: what starts it on magpie typed in a new terminal, a function
// magpie gave the user's shells (agy); the launch is for one open now
Typed string `json:"typed,omitempty"`
// Models: how many of the catalog its lists show, for an agent that
// picks among it (agent_models.go)
Models *modelCountJSON `json:"models,omitempty"`
// Menu: its own model menu is the models picked here, no one model to
// start on (agent.ListsModels): ZCode's, Cursor Private Inference's
Menu bool `json:"menu,omitempty"`
// NoNames: its own list doesn't name magpie's models as Names in agents'
// lists says (agent.NoNames), for that setting to say so
NoNames bool `json:"noNames,omitempty"`
// Source: what an agent not connected runs on now (agent.Source), and
// Stale: copies of a connected one still running on the list they
// started with (agent.Stale), for the line under its name
Source string `json:"source,omitempty"`
Stale int `json:"stale,omitempty"`
// StaleCopies: those copies, each with what it is and when it
// started, for the opened row to say which is left to reopen and how
StaleCopies []agent.StaleCopy `json:"staleCopies,omitempty"`
// AppRestart: its desktop app (Claude Desktop, WorkBuddy) running on
// what it read before magpie's last change, for the row's Restart
// (agent.AppBehind)
AppRestart *agent.AppRun `json:"appRestart,omitempty"`
// Joined: connected with its own models still in its list (Codex
// signed in with ChatGPT, agent.Agent.Join)
Joined bool `json:"joined,omitempty"`
// AppOut: magpie is Codex's provider while the ChatGPT account it is
// signed in to is used up (agent.Agent.AppOut), which turns the Codex
// app's ChatGPT side off until the reset
AppOut *appOutJSON `json:"appOut,omitempty"`
// Failover: not connected, yet its requests go through magpie for
// account failover alone (agent.Agent.FailingOver, #1385)
Failover bool `json:"failover,omitempty"`
// CLIMissing: its settings are here, its CLI isn't (#843), which
// the row says with none of its settings offered (#2177), and Install
// another agent offers it again where magpie knows how
CLIMissing bool `json:"cliMissing,omitempty"`
Native *agent.NativeState `json:"native,omitempty"`
}
// clientJSON is an agent, or another client the gateway knows, as a
// request from it is drawn.
type clientJSON struct {
ID string `json:"id"`
Name string `json:"name"`
Icon string `json:"icon"`
}
type profileJSON struct {
Name string `json:"name"`
Summary string `json:"summary"`
// Library is what the profile gives out from the library, for one
// saved with its setup
Library *profileLibraryJSON `json:"library,omitempty"`
// Agents is what it holds, by agent, to be read before it is applied
// (#467); a value that reads as a key or a token is left out
Agents []profile.Group `json:"agents"`
// InUse: the setup is this profile now, applying it would change
// nothing (profile.InUse); the page marks it so (superhtoooth on X:
// nothing said which profile was in use)
InUse bool `json:"inUse,omitempty"`
}
type profileLibraryJSON struct {
Servers int `json:"servers"` // given to at least one agent
Skills int `json:"skills"` // given to at least one agent
Instructions bool `json:"instructions"` // some agent gets them
}
type stateJSON struct {
Agents []agentJSON `json:"agents"`
Clients []clientJSON `json:"clients"` // who a request may come from, by id
Profiles []profileJSON `json:"profiles"`
Catalog string `json:"catalog"`
Notice string `json:"notice,omitempty"` // advice after a change, e.g. "restart Codex"
// Connected is how the 「接入」 switch chose the model the agent starts
// on, in the answer to agents/connect (agent.Connection)
Connected *agent.Connection `json:"connected,omitempty"`
// CLIBehind is the terminal's magpie command, told to the user when
// it's a copied file rather than the installer's link: a copy can't
// follow updates (#531's lesson). "" when it's the link or absent, or
// the advice was dismissed for this version.
CLIBehind string `json:"cliBehind,omitempty"`
// ConfigBlocked is the folder this user can't write that keeps magpie
// from saving its files (a ~/.config sudo left root's), which the
// window offers to make theirs again; "" when magpie can save
ConfigBlocked string `json:"configBlocked,omitempty"`
Settings settings.Settings `json:"settings"`
// FX is the dollar-to-yuan rate the cny currency choice shows costs at,
// here too (not only in settingsJSON) so a cost drawn before the reader
// ever opens Settings already converts, if cny was chosen last time.
FX fxJSON `json:"fx"`
// Unlisted are the models kept for routing groups, which the pickers
// don't offer: a filter that finds one of them says why it isn't there
Unlisted []unlistedJSON `json:"unlisted,omitempty"`
// Recovered are magpie's files a crash left unreadable (all zero,
// #1505) that were read from their last good generation: the page
// tells the user once each
Recovered []lastgood.Note `json:"recovered,omitempty"`
// Last: this is the state kept from the last read (laststate.go), for
// the page to draw while the fresh one is read
Last bool `json:"last,omitempty"`
// Served is how many models magpie serves, groups left out: the Get
// started card's first step ("add a model source") is done once
// there is one, agents found or not
Served int `json:"served"`
}
// unlistedJSON is a model of a provider kept for routing groups, and the
// groups ("group/<id>") it is used through, none when it is in no group.
type unlistedJSON struct {
ID string `json:"id"`
Name string `json:"name"`
Provider string `json:"provider"`
Icon string `json:"icon,omitempty"`
Groups []string `json:"groups"`
}
// unlistedModels lists provider.Unlisted for the page.
func unlistedModels() []unlistedJSON {
es := provider.Unlisted()
if len(es) == 0 {
return nil
}
in := provider.MemberGroups()
out := make([]unlistedJSON, 0, len(es))
for _, e := range es {
gs := in[e.ID]
if gs == nil {
gs = []string{}
}
out = append(out, unlistedJSON{ID: e.ID, Name: e.Name, Provider: e.Provider.Name, Icon: e.Provider.Icon, Groups: gs})
}
return out
}
// fxJSON is a USD→CNY rate as the UI shows it: the number a cost is
// multiplied by, when it was last learned (unset for Fallback, never
// learned from anywhere), and whether that's stale — the Settings page's
// currency row puts these in its tooltip.
type fxJSON struct {
Rate float64 `json:"rate"`
At *time.Time `json:"at,omitempty"`
Stale bool `json:"stale"`
}
// currentFX is the rate known now, never waited for: a stale one is asked
// for behind it and shown on the next look (#541: the state waited up to
// 4s on the network after each TTL, at every morning's start-up).
func currentFX() fxJSON {
r := fx.Soon()
out := fxJSON{Rate: r.CNYPerUSD, Stale: r.Stale()}
if !r.At.IsZero() {
at := r.At
out.At = &at
}
return out
}
// settingsJSON is the Settings page: the two choices plus the facts it shows.
type settingsJSON struct {
settings.Settings
Version string `json:"version"`
Dir string `json:"dir"` // where magpie keeps its files, as shown
Gateway string `json:"gateway"` // the local endpoint
// Builtins are the built-in plugins: each one's switch, whether it
// runs and what of it is in use (builtins.go)
Builtins []builtinJSON `json:"builtins"`
// JSRoutings are the routings JS gateway plugins serve now
// ("<plugin>/<name>"), for the routing pickers
JSRoutings []middleware.Routing `json:"jsRoutings"`
// PublicURL is MAGPIE_PUBLIC_URL while other machines are let in
// (shared, or MAGPIE_ADDR on the network): where they reach the
// gateway, shown beside the local address agents here are pointed at
// (#1551)
PublicURL string `json:"publicURL,omitempty"`
// MAGPIE_ADDR, when it sets the gateway's address over Settings' port
AddrEnv string `json:"addrEnv,omitempty"`
// MAGPIE_ALLOW_IPS, when it sets the allow list over Settings', and
// the list it sets; OnNetwork: MAGPIE_ADDR listens on the network, so
// the list is shown even while sharing is off
AllowIPsEnv string `json:"allowIPsEnv,omitempty"`
AllowIPsFromEnv []string `json:"allowIPsFromEnv,omitempty"`
OnNetwork bool `json:"onNetwork,omitempty"`
// Dir is the data folder beside a portable magpie (#508)
Portable bool `json:"portable,omitempty"`
// WSL is whether there is WSL to look in for agents (Windows), for
// Settings' Detect agents in WSL (#1264)
WSL bool `json:"wsl,omitempty"`
// Rekeyed is what an agent beyond loopback, given the sharing key,
// couldn't be set again with when sharing changed (agent.Rekey)
Rekeyed string `json:"rekeyed,omitempty"`
// Notice is a Settings row's warning when a setting can't take effect:
// the Codex subagents row when Codex's own multi_agent_v2 is on in the
// config magpie routes (#141)
Notice string `json:"notice,omitempty"`
// Mac apps that explicitly handle .command files, for resumed sessions.
TerminalApps []terminalChoice `json:"terminalApps,omitempty"`
TerminalDefault string `json:"terminalDefault,omitempty"`
OTelEnv bool `json:"otelEnv,omitempty"`
// NoAccountsEnv is MAGPIE_NO_ACCOUNTS set, which keeps account
// discovery off for this run whatever Settings has (#1535)
NoAccountsEnv bool `json:"noAccountsEnv,omitempty"`
// whether the page is in gateway mode and why (gatewayMode); Web says
// it is served by magpie web, where the mode can be set
GatewayOn bool `json:"gatewayOn,omitempty"`
GatewayWhy string `json:"gatewayWhy,omitempty"`
Web bool `json:"web,omitempty"`
// the proxy vendor requests go through now, and where it came from:
// settings, environment, system, off or none
ProxyNow string `json:"proxyNow"`
ProxySource string `json:"proxySource"`
// whether magpie opens at login: the system's record, not a setting;
// LoginAllow, the record is there but the user switched it off in
// System Settings › Login Items, which is where it's allowed again
Login bool `json:"login"`
LoginAllow bool `json:"loginAllow,omitempty"`
// the model that describes images when Vision names none, and those
// that can be named
VisionAuto string `json:"visionAuto,omitempty"`
VisionModels []modelRef `json:"visionModels"`
// the Vision the user picked when magpie can't find it any more:
// VisionAuto describes in its place, and the row says so
VisionMissing string `json:"visionMissing,omitempty"`
// VisionNotMarked are the custom providers (AddedByAddress) with a model left
// out of VisionModels only because nothing says it takes images: the
// user can say so in the provider's Names & levels (nexnull on Discord)
VisionNotMarked []string `json:"visionNotMarked,omitempty"`
// the reasoning levels of the model that describes images now, and the
// one it is asked at when one is picked (VisionEffort fitted to them)
VisionEfforts []string `json:"visionEfforts,omitempty"`
VisionEffortNow string `json:"visionEffortNow,omitempty"`
// the models Codex's thread titles may be sent to (CodexTitles, #705)
TitleModels []modelRef `json:"titleModels"`
// the models a request masking would change may go to as written
// (RedactRouteTo): those whose every route is set to go unmasked
// (gateway.MaskRoute)
MaskRouteModels []modelRef `json:"maskRouteModels"`
// what each of the disabled models (#1867) turns off now, by pattern
DisabledHits map[string][]string `json:"disabledHits,omitempty"`
// the model magpie's generate_image tool draws with when ImageGen
// names none, and those that can be named
ImageGenAuto string `json:"imageGenAuto,omitempty"`
// the ImageGen the user picked when magpie can't find it any more
ImageGenMissing string `json:"imageGenMissing,omitempty"`
// the listed model the ImageGen the user picked stands for, when it
// isn't listed itself: a ChatGPT account's gpt-image-2.5, saved when
// magpie listed it, is its one GPT Image (gateway.ListedDrawer, #1865)
ImageGenShown string `json:"imageGenShown,omitempty"`
ImageGenModels []modelRef `json:"imageGenModels"`
// the ImageGen the user picked is one unticked in its provider's
// editor since (provider.HiddenDrawers): it still draws, and is
// listed, as picked, with the row saying it is hidden
ImageGenHidden bool `json:"imageGenHidden,omitempty"`
// the web search APIs a model's search goes to when no provider can
// search (#419), their keys masked; the ones that can be added; and
// the provider that searches first, if one does
SearchAPIs []searchAPIJSON `json:"searchAPIs"`
SearchVendors []searchVendorJSON `json:"searchVendors"`
SearchProvider string `json:"searchProvider,omitempty"`
// the providers Settings' Searcher may name, the one magpie picks when
// it names none, why the one it names isn't used (gateway.Searcher*),
// and the relays said to search that are never picked automatically (#359)
SearchChoices []searchChoiceJSON `json:"searchChoices"`
SearchAuto string `json:"searchAuto,omitempty"`
SearchUnused string `json:"searchUnused,omitempty"`
// the reasoning levels of the model that searches now, and the one it
// is asked at when one is picked (SearcherEffort fitted to them)
SearchEfforts []string `json:"searchEfforts,omitempty"`
SearchEffortNow string `json:"searchEffortNow,omitempty"`
SearchRelays []string `json:"searchRelays,omitempty"`
// the last search the one it names didn't make, since it last
// searched: no other provider searched in its place (Gearclickist on
// Discord)
SearchFailed *searchFailedJSON `json:"searchFailed,omitempty"`
// the providers on that aren't offered, as they can't search the web
// by themselves (#825)
SearchLeftOut []string `json:"searchLeftOut,omitempty"`
// the GitHub token the library asks GitHub with, masked, and where it
// is from ("settings", GITHUB_TOKEN or GH_TOKEN); never the token
GitHubTokenMask string `json:"githubTokenMask,omitempty"`
GitHubTokenFrom string `json:"githubTokenFrom,omitempty"`
// the token set in Settings was refused by GitHub (401): it is still
// shown, masked, while requests go without a token (#3926)
GitHubTokenRefused bool `json:"githubTokenRefused,omitempty"`
// where other machines reach the gateway while it is shared
LANURLs []string `json:"lanURLs,omitempty"`
// LANURLs are a container's own addresses, not the host's: the page
// offers the one it was opened at instead, or says how to set it
LANContainer bool `json:"lanContainer,omitempty"`
// those of LANURLs at an internet address, which anyone online can
// reach, not only this network
LANPublic []string `json:"lanPublic,omitempty"`
// when the Codex warm-up last started an account's window
CodexWarmed *time.Time `json:"codexWarmed,omitempty"`
// and the Claude warm-up
ClaudeWarmed *time.Time `json:"claudeWarmed,omitempty"`
// the ChatGPT accounts signed in, each of which can have a daily
// warm-up time of its own (#957)
CodexUsers []string `json:"codexUsers,omitempty"`
// and the Claude accounts, which Warm up now picks from
ClaudeUsers []string `json:"claudeUsers,omitempty"`
// the Codexes here that kept the background compaction's table (and
// its share) out of the config at the last sync: too old for it
// (before 0.163.0-alpha.8), or of no known version (codex_async.go)
CodexAsyncHeld []agent.CodexReader `json:"codexAsyncHeld,omitempty"`
// whether a WorkBuddy (China) account is signed in, and each one's
// last daily check-in
WorkBuddy bool `json:"workbuddy"`
WorkBuddyCheckins []provider.WorkBuddyCheckin `json:"workbuddyCheckins,omitempty"`
// and a Trae CN account (its plugin's), and theirs (#694)
Trae bool `json:"trae"`
TraeCheckins []provider.WorkBuddyCheckin `json:"traeCheckins,omitempty"`
// and a MiniMax Code (China) account (its plugin's), and theirs (#811)
MiniMax bool `json:"minimax"`
MiniMaxCheckins []provider.WorkBuddyCheckin `json:"minimaxCheckins,omitempty"`
// and a Qoder or Qoder CN account (its plugin's), and theirs
Qoder bool `json:"qoder"`
QoderCheckins []provider.WorkBuddyCheckin `json:"qoderCheckins,omitempty"`
// every account each vendor's daily check-in reaches, and whether the
// user left it out (#1902)
CheckinAccounts []provider.CheckinAccount `json:"checkinAccounts,omitempty"`
// and the plugins' providers that check in themselves (auth.checkin),
// each with its switch and its accounts' last check-ins
CheckinPlugins []provider.PluginCheckin `json:"checkinPlugins,omitempty"`
// FX is the dollar-to-yuan rate the cny currency choice shows costs at
FX fxJSON `json:"fx"`
// NotifyProblem is why a usage alert set wouldn't be seen: "denied"
// (notifications turned off for magpie) or "unavailable"
NotifyProblem string `json:"notifyProblem,omitempty"`
}
// searchAPIJSON is a search API as the Settings page shows it.
type searchAPIJSON struct {
Vendor string `json:"vendor"`
Name string `json:"name"`
Key string `json:"key,omitempty"` // masked
URL string `json:"url,omitempty"`
Ready bool `json:"ready"`
// Keys is how many keys it has, Pick how a search picks among them
// (provider.SearchPick*), and Quota whether what each has left can be
// read (gateway.SearchQuotas)
Keys int `json:"keys,omitempty"`
Pick string `json:"pick,omitempty"`
Quota bool `json:"quota,omitempty"`
// Off: switched off, kept but never asked (#2286)
Off bool `json:"off,omitempty"`
}
// searchChoiceJSON is a provider that can search for a model that can't,
// with the model it searches with when none is named, and its models.
type searchChoiceJSON struct {
ID string `json:"id"`
Name string `json:"name"`
Icon string `json:"icon,omitempty"`
Small string `json:"small"`
SmallName string `json:"smallName,omitempty"`
Models []modelRef `json:"models"`
// Service is a Kimi Code plan, which searches by its search service:
// named by itself, with no model
Service bool `json:"service,omitempty"`
// Own is a Google sign-in, which searches for its own models first
Own bool `json:"own,omitempty"`
}
type searchVendorJSON struct {
ID string `json:"id"`
Name string `json:"name"`
KeysURL string `json:"keysURL,omitempty"`
NeedURL bool `json:"needURL,omitempty"` // one the user runs
// KeyOptional: it can be added with no key (You.com's free search, #1626)
KeyOptional bool `json:"keyOptional,omitempty"`
// its own address, the one used while no base URL is set (#1580)
Base string `json:"base,omitempty"`
}
func searchState(s *settingsJSON) {
names := map[string]string{}
for _, e := range provider.Served() {
names[e.ID] = cmp.Or(e.Name, e.Model)
}
s.SearchAPIs, s.SearchVendors = []searchAPIJSON{}, []searchVendorJSON{}
for _, a := range provider.StoredSearchAPIs() {
j := searchAPIJSON{Vendor: a.Vendor, Name: a.Name(), URL: a.URL, Ready: a.Ready(), Keys: len(a.Keys()), Pick: a.Pick, Quota: gateway.CanReadSearchQuota(a), Off: a.Off}
if a.Key != "" {
j.Key = a.MaskedKey()
}
s.SearchAPIs = append(s.SearchAPIs, j)
}
for _, v := range provider.SearchVendors {
s.SearchVendors = append(s.SearchVendors, searchVendorJSON{ID: v.ID, Name: v.Name, KeysURL: v.KeysURL, NeedURL: v.Base == "", KeyOptional: v.KeyOptional, Base: v.Base})
}
s.SearchProvider = gateway.Searcher()
s.SearchAuto, s.SearchUnused = gateway.AutoSearcher(), gateway.SearcherUnused()
s.SearchEfforts, s.SearchEffortNow = gateway.SearchEfforts(), gateway.SearchEffortNow()
if f, ok := gateway.SearcherFailed(); ok {
s.SearchFailed = &searchFailedJSON{Searcher: f.Searcher, Why: f.Why, NothingFound: f.NothingFound, NotSearched: f.NotSearched, At: f.At}
}
s.SearchChoices = []searchChoiceJSON{}
for _, c := range gateway.Searchers() {
p := c.Provider
j := searchChoiceJSON{ID: p.ID, Name: p.Name, Icon: p.Icon, Small: c.Small, SmallName: names[p.ID+"/"+c.Small], Models: []modelRef{}, Service: c.Service, Own: c.Own}
for _, m := range c.Models {
id := p.ID + "/" + m.ID
j.Models = append(j.Models, modelRef{ID: id, Name: cmp.Or(names[id], m.Name, m.ID), Provider: p.ID, PName: p.Name, Icon: p.Icon})
}
s.SearchChoices = append(s.SearchChoices, j)
}
for _, p := range gateway.RelaysSaidToSearch() {
s.SearchRelays = append(s.SearchRelays, p.Name)
}
for _, p := range provider.All() {
if p.On() && !slices.ContainsFunc(s.SearchChoices, func(c searchChoiceJSON) bool { return c.ID == p.ID }) && !slices.Contains(s.SearchRelays, p.Name) {
s.SearchLeftOut = append(s.SearchLeftOut, p.Name)
}
}
}
// searchFailedJSON is gateway.SearchFailure as Settings shows it.
type searchFailedJSON struct {
Searcher string `json:"searcher"`
Why string `json:"why,omitempty"`
NothingFound bool `json:"nothingFound,omitempty"`
NotSearched bool `json:"notSearched,omitempty"`
At time.Time `json:"at"`
}
// loginState is whether magpie opens at login, as the system will act on
// it. A var for the tests: the real one asks the user's own system.
var loginState = autostart.Enabled
func settingsState() settingsJSON {
s := settingsJSON{Settings: settings.Load(), Version: Version, Dir: tilde(settings.Dir()), Portable: settings.Portable() != "", Gateway: gateway.URL()}
s.AddrEnv = os.Getenv("MAGPIE_ADDR")
s.Builtins = builtinsState()
s.JSRoutings = middleware.Routings()
s.OnNetwork = gateway.OnNetwork()
if list, env := gateway.AllowIPs(); env {
s.AllowIPsEnv, s.AllowIPsFromEnv = os.Getenv(gateway.AllowIPsEnv), list
}
if s.LAN || gateway.OnNetwork() {
s.PublicURL = gateway.PublicURL()
}
s.WSL = runtime.GOOS == "windows"
s.Web = webPage.Load()
s.GatewayOn, s.GatewayWhy = gatewayMode(s.Web)
s.LANKey = "" // the retained credential belongs on disk, not in UI state
// the GitHub token, masked, and where the library's requests take one
// from: Settings, or the environment variable named
own := strings.TrimSpace(s.GitHubToken)
s.GitHubToken = ""
if tok, from := library.GitHubToken(); tok != "" {
s.GitHubTokenMask, s.GitHubTokenFrom = provider.Mask(tok), from
} else if _, refused := ghtoken.SettingsRefused(); refused && own != "" {
// a refused token set here is still the user's: shown as refused,
// not as if none were set, while requests go without one (#3926)
s.GitHubTokenMask, s.GitHubTokenFrom, s.GitHubTokenRefused = provider.Mask(own), "settings", true
}
if found, err := discoverTerminals(); err == nil {
for _, app := range found.Apps {
s.TerminalApps = append(s.TerminalApps, terminalChoice{ID: app.ID, Name: app.Name})
}
s.TerminalDefault = found.Default
}
s.FX = currentFX()
if (s.UsageAlert > 0 || s.BalanceAlert > 0 || s.ResetReminder > 0 || s.TurnDoneAlert > 0 || s.MaskAlert) && notifyProblem != nil {
s.NotifyProblem = notifyProblem()
}
s.ProxyNow, s.ProxySource = netproxy.Describe()
s.NoAccountsEnv = settings.AccountDiscoveryOff() && !s.NoAccountDiscovery
for _, name := range []string{"MAGPIE_OTEL_ENABLED", "MAGPIE_OTEL_ENDPOINT", "MAGPIE_OTEL_HEADERS", "MAGPIE_OTEL_METRICS", "MAGPIE_OTEL_BODIES", "MAGPIE_OTEL_BODIES_WHOLE", "MAGPIE_OTEL_SESSIONS"} {
if _, ok := os.LookupEnv(name); ok {
s.OTelEnv = true
}
}
login := loginState()
s.Login, s.LoginAllow = login != autostart.Off, login == autostart.NeedsAllowing
if s.LAN {
s.LANURLs, s.LANContainer = gateway.LANURLs(), gateway.ContainerAddrs()
s.LANPublic = gateway.PublicURLs(s.LANURLs)
}
s.CodexWarmed, s.ClaudeWarmed = latest(provider.CodexWarmed()), latest(provider.ClaudeWarmed())
s.CodexUsers, s.ClaudeUsers = loginUsers("codex"), loginUsers("claude")
s.CodexAsyncHeld = agent.CodexAsyncHeld()
s.WorkBuddy, s.WorkBuddyCheckins = provider.HasWorkBuddy(), provider.WorkBuddyCheckins()
s.Trae, s.TraeCheckins = provider.HasTrae(), provider.TraeCheckins()
s.MiniMax, s.MiniMaxCheckins = provider.HasMiniMax(), provider.MiniMaxCheckins()
s.Qoder, s.QoderCheckins = provider.HasQoder(), provider.QoderCheckins()
s.CheckinPlugins = provider.PluginCheckins()
s.CheckinAccounts = provider.CheckinAccounts()
s.VisionAuto, s.VisionModels, s.VisionMissing = gateway.AutoVision(), []modelRef{}, gateway.VisionMissing()
s.VisionEfforts, s.VisionEffortNow = gateway.VisionEfforts(), gateway.VisionEffortNow()
for _, e := range provider.Served() {
if e.Images && (e.ImageInput == nil || *e.ImageInput) && (e.Group != "" || e.Provider.Ready()) {
m := modelRef{ID: e.ID, Name: e.Name, Provider: e.Provider.ID, PName: e.Provider.Name, Icon: e.Provider.Icon}
if e.Group != "" {
m.Provider, m.PName = "", e.Group
}
s.VisionModels = append(s.VisionModels, m)
} else if e.Group == "" && !e.Images && e.ImageInput == nil && e.Provider.AddedByAddress() && e.Provider.Ready() &&
!slices.Contains(s.VisionNotMarked, cmp.Or(e.Provider.Name, e.Provider.ID)) {
// unknown, not answered: one its list or the user said no to
// (ModelImages) isn't counted
s.VisionNotMarked = append(s.VisionNotMarked, cmp.Or(e.Provider.Name, e.Provider.ID))
}
}
s.TitleModels, s.MaskRouteModels = []modelRef{}, []modelRef{}
// only a provider set to go unmasked can take one (most have none)
unmaskedAny := slices.ContainsFunc(provider.All(), provider.Provider.SkipsRedaction)
for _, pat := range s.DisabledModels {
if s.DisabledHits == nil {
s.DisabledHits = map[string][]string{}
}
s.DisabledHits[pat] = provider.DisabledHits(pat)
}
for _, e := range provider.Served() {
if e.Group != "" || e.Provider.Ready() && !e.Provider.DecideOnly() {
m := modelRef{ID: e.ID, Name: e.Name, Provider: e.Provider.ID, PName: e.Provider.Name, Icon: e.Provider.Icon}
if e.Group != "" {
m.Provider, m.PName = "", e.Group
}
s.TitleModels = append(s.TitleModels, m)
if (e.Group != "" || e.Provider.SkipsRedaction()) && unmaskedAny && gateway.MaskRoute(e.ID) {
s.MaskRouteModels = append(s.MaskRouteModels, m)
}
}
}
searchState(&s)
s.ImageGenAuto, s.ImageGenModels, s.ImageGenMissing = gateway.AutoDrawer(), []modelRef{}, gateway.DrawerMissing()
for _, p := range provider.All() {
if !p.On() || p.DecideOnly() {
continue
}
// those unticked in its editor left out, but the one picked here
// (321sssrt on X): a hidden pick still draws, and shows as picked
for _, m := range gateway.Drawers(p) {
if p.DrawerHidden(m.ID) && gateway.ListedDrawer(s.ImageGen) != p.ID+"/"+m.ID {
continue
}
name := m.Name
if name == "" {
name = m.ID
}
s.ImageGenModels = append(s.ImageGenModels, modelRef{ID: p.ID + "/" + m.ID, Name: name, Provider: p.ID, PName: p.Name, Icon: p.Icon, VendorPicks: gateway.VendorPicksDrawer(p)})
}
}
// the routing groups with a member that draws (7up6666 on X): a
// group picked here draws on its members in its routing's order
for _, e := range provider.Served() {
if e.Group != "" && gateway.GroupDraws(e.ID) {
s.ImageGenModels = append(s.ImageGenModels, modelRef{ID: e.ID, Name: e.Name, PName: e.Group})
}
}
if v := gateway.ListedDrawer(s.ImageGen); v != s.ImageGen {
s.ImageGenShown = v
}
s.ImageGenHidden = gateway.DrawerHidden(s.ImageGen)
// the Codex subagents row's warning: magpie's multi-agent V1 doesn't reach
// Codex where its own multi_agent_v2 is on in the config magpie routes, and
// magpie writes nothing there — the setting is the user's to turn off
// (#141). Shown on every read, so the row carries it after a reload too.
if s.CodexAgentsV1 {
s.Notice = agent.CodexSubAgentsV1Warning()
}
return s
}
// latest is the latest of ts, nil when there is none.
func latest(ts map[string]time.Time) *time.Time {
var out *time.Time
for _, t := range ts {
if out == nil || t.After(*out) {
out = &t
}
}
return out
}
// onDock puts the app in the Mac's Dock or takes it out as the settings say,
// when the Settings page changes them; set by the process that has the app.
var onDock func(settings.Settings)
// assetTypes are the page's own files' types. The file server takes them
// from Windows' registry, which another program may have changed — an SVG
// served as something else draws no icon.
var assetTypes = map[string]string{".svg": "image/svg+xml", ".png": "image/png", ".css": "text/css; charset=utf-8",
".js": "text/javascript; charset=utf-8", ".html": "text/html; charset=utf-8"}
func init() {
for ext, t := range assetTypes {
mime.AddExtensionType(ext, t)
}
}
// revalidated serves the page's own files to be asked for again each time,
// by their content's hash: an embedded file has no date, so they went out
// with nothing to check them by, and a cache in front of `magpie web` (a
// proxy, a CDN, a tunnel's) could keep an older version's app.js under the
// new index.html after an update: a page without what that version added,
// such as the request archive switch (Jorben on Discord). An unchanged
// file is a 304.
//
// The page itself names each of its scripts and styles with its content's
// hash (app.js?v=…), so a cache that kept a file from before these headers
// were sent, and goes on serving it whatever magpie says now, is never asked
// for it again: a Docker user behind an HTTPS proxy had v0.1.630's page run
// v0.1.582's app.js and routing.js (incognito and a hard refresh alike),
// whose first lines looked for an element the page no longer had, and the
// page was blank under its tabs.
func revalidated(next http.Handler) http.Handler {
return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
name := strings.TrimPrefix(path.Clean("/"+r.URL.Path), "/")
if name == "" {
name = "index.html"
}
b, err := fs.ReadFile(staticFS(), name)
if err != nil {
next.ServeHTTP(rw, r)
return
}
if r.URL.Path == "/" {
b = versionedPage(b)
}
sum := sha256.Sum256(b)
rw.Header().Set("ETag", `"`+hex.EncodeToString(sum[:12])+`"`)
rw.Header().Set("Cache-Control", "no-cache")
// a file asked for by the address the page names it by, its
// content's hash, is the same at that address for good: a browser
// keeps it and doesn't ask again, which a slow link to `magpie web`
// feels at every load (akic404 on Discord). Another version's hash,
// or none, is asked for again as before.
if v := r.URL.Query().Get("v"); v != "" && v == hex.EncodeToString(sum[:6]) {
rw.Header().Set("Cache-Control", "max-age=31536000, immutable")
}
if r.URL.Path == "/" {
rw.Header().Set("Content-Type", "text/html; charset=utf-8")
http.ServeContent(rw, r, "index.html", time.Time{}, bytes.NewReader(b))
return
}
next.ServeHTTP(rw, r)
})
}
// pageFile is a script or stylesheet of the page's own, named in it: one
// of the page's, or of a built-in plugin's under plugins/<id>/.
var pageFile = regexp.MustCompile(`(src|href)="([A-Za-z0-9_.-]+(?:/[A-Za-z0-9_.-]+)*\.(?:js|css))"`)
// versionedPage is the page with each of its own scripts and stylesheets
// named with its content's hash; one not among the page's files (boot.js,
// which the API writes) keeps its name.
func versionedPage(page []byte) []byte {
return pageFile.ReplaceAllFunc(page, func(m []byte) []byte {
g := pageFile.FindSubmatch(m)
b, err := fs.ReadFile(staticFS(), string(g[2]))
if err != nil {
return m
}
sum := sha256.Sum256(b)
return []byte(fmt.Sprintf(`%s="%s?v=%s"`, g[1], g[2], hex.EncodeToString(sum[:6])))
})
}
// Handler serves the embedded UI and the JSON API.
// gw is the gateway this process serves, or nil when another magpie has it
// (for now: see startBackend).
func Handler(w Windows, gw *gateway.Server) http.Handler {
if gw != nil {
served.Store(gw)
}
// magpie web's own page, not the app's served to a browser, which the
// app's windows share their settings state with
if ownWeb(w) {
webPage.Store(true)
}
mux := http.NewServeMux()
mux.Handle("/", devPage(revalidated(http.FileServer(http.FS(staticFS())))))
devRoutes(mux)
pluginPageRoutes(mux, isWeb(w))
// boot.js hands the page the saved language and theme before it paints:
// they came only with the settings, so the tabs showed English first
mux.HandleFunc("GET /boot.js", func(rw http.ResponseWriter, r *http.Request) {
s := settings.Load()
// and the text size, which the Mac's header measures against the
// traffic lights
boot := map[string]any{"lang": s.Lang, "theme": s.Theme, "textSize": s.TextSize, "web": isWeb(w)}
if s.Colorblind {
boot["colorblind"] = true
}
if s.ReduceMotion {
boot["reduceMotion"] = true
}
if s.NoBird {
boot["noBird"] = true
}
// a browser tab keeps its own font choice (fonts.js)
if !isWeb(w) {
boot["uiFont"], boot["codeFont"] = s.UIFont, s.CodeFont
}
// and whether this app's webview would crash on a <video> (Linux
// without gst-plugins-good, webkitPlaysVideo), so the pages show
// none. Here, not in the settings: the page's settings come from
// /api/state, which never said it, so the masking demo set its
// video and the web process aborted (avk458 on X, omarchy)
if !isWeb(w) && !webkitPlaysVideo() {
boot["noVideo"] = true
}
// and whether it is a gateway's page alone (gatewaymode.go), so the
// pages left out never show
if on, _ := gatewayMode(ownWeb(w)); on {
boot["gateway"] = true
}
// and the built-in plugins it leaves out (builtins.go), gone
// before the first paint rather than after the settings come
list := builtinsState()
boot["featuresOff"] = builtinsOff(list)
// and where the gateway listens, so the sidebar's line at its foot
// is drawn from the start, not held back until providers has come
// in (#1519's read waits for the agents); only this process's own,
// for one served by another magpie is the providers' read to find
if served.Load() != nil {
side := map[string]any{"url": gateway.URL(), "running": true, "boot": true}
// and MAGPIE_PUBLIC_URL while other machines are let in, which
// a page they open (magpie web) shows instead (noahhrreion on
// Discord: in Docker the line said the container's loopback)
// and, shared, the addresses other machines use, which the
// window's line names from the first paint (coeo91 on Discord)
if s.LAN || gateway.OnNetwork() {
side["lan"], side["lanURLs"] = true, gateway.LANURLs()
if u := gateway.PublicURL(); u != "" {
side["publicURL"] = u
}
}
boot["sideGateway"] = side
}
// and the settings of those the page draws (kernel.js)
boot["pluginConfig"] = builtinConfig(list)
// on Omarchy the page takes its theme's look before it paints
if th, ok := omarchyTheme(); ok {
boot["omarchy"] = th
}
b, _ := json.Marshal(boot)
rw.Header().Set("Content-Type", "text/javascript; charset=utf-8")
rw.Header().Set("Cache-Control", "no-store")
rw.Write(append(append([]byte("window.bootPrefs = "), b...), ";\n"...))
})
// the Omarchy theme as it is now, asked again every few seconds so a
// theme picked in Omarchy's menu reaches the page at once; null off Omarchy
mux.HandleFunc("GET /api/omarchy", func(rw http.ResponseWriter, r *http.Request) {
if th, ok := omarchyTheme(); ok {
writeJSON(rw, th)
return
}
writeJSON(rw, nil)
})
omarchyRoutes(mux, w)
fontRoutes(mux, isWeb(w), !fonts.Available, fonts.List)
mux.HandleFunc("GET /api/state", func(rw http.ResponseWriter, r *http.Request) {
// the panel and its model picker load from here: an account still
// without its vendor's list (one whose try at start-up failed) is
// asked again in the background, not only from the Providers page
provider.FetchNewSoon(8 * time.Second)
// ?last=1: the state kept from the last read, at once (#1519);
// null when none is kept
if r.URL.Query().Get("last") == "1" {
if s, ok := lastKnown(); ok {
writeJSON(rw, s)
} else {
writeJSON(rw, nil)
}
return
}
s := state()
writeJSON(rw, s)
keepState(s)
})
mux.HandleFunc("POST /api/set", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Agent, Field, Value string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
a, err := agent.Find(in.Agent)
if err != nil {
fail(rw, err)
return
}
f := a.Field(in.Field)
if f == nil {
http.Error(rw, "unknown field", http.StatusBadRequest)
return
}
wired := a.Wired()
if err := a.Pick(f.Key, strings.TrimSpace(in.Value)); err != nil {
fail(rw, err)
return
}
s := state()
if a.Notice != nil && (!f.Live || !wired && a.Wired()) {
s.Notice = a.Notice()
}
writeJSON(rw, s)
})
// reapply sets again what magpie set on an agent something else
// rewrote; keep takes the agent as it is now
// what drifted, per agent: cheap enough to ask while the window is up,
// so a config rewritten elsewhere shows without a reload
mux.HandleFunc("GET /api/drift", func(rw http.ResponseWriter, r *http.Request) {
out := map[string]*agent.Drift{}
for _, a := range agent.Detected() {
if d := a.Drift(); d != nil {
out[a.ID] = d
}
}
writeJSON(rw, out)
})
// the agents' CLIs: their versions and the newest (#202), as far as
// they're known within a moment — the rest are asked on meanwhile, and
// pending says to ask again soon
// the Agents page's refresh: looks for the agents on this machine again,
// the answers kept a while because asking was slow forgotten (#844)
mux.HandleFunc("POST /api/agents/rescan", func(rw http.ResponseWriter, r *http.Request) {
agent.Rescan()
writeJSON(rw, state())
})
mux.HandleFunc("GET /api/agents/cli", func(rw http.ResponseWriter, r *http.Request) {
clis, pending := agent.CLIs(3 * time.Second)
writeJSON(rw, map[string]any{"agents": clis, "pending": pending})
})
// the agents magpie knows that aren't here, with their vendors' install
// commands to copy (#727)
mux.HandleFunc("GET /api/agents/install", func(rw http.ResponseWriter, r *http.Request) {
writeJSON(rw, agent.Installs())
})
// Aside's explicit offline model write. Normal model changes require its runtime.
mux.HandleFunc("POST /api/agents/stage/{id}", func(rw http.ResponseWriter, r *http.Request) {
a, err := agent.Find(r.PathValue("id"))
if err != nil {
fail(rw, err)
return
}
var in struct{ Field, Value string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
if a.Native == nil || a.Native.Stage == nil {
fail(rw, fmt.Errorf("this agent does not support staged model settings"))
return
}
value, err := a.Spell(in.Field, in.Value)
if err != nil {
fail(rw, err)
return
}
if err := a.Native.Stage(in.Field, value); err != nil {
fail(rw, err)
return
}
writeJSON(rw, state())
})
// updates one the way it was installed; what it is afterwards comes
// back with an error too
mux.HandleFunc("POST /api/agents/cli/{id}", func(rw http.ResponseWriter, r *http.Request) {
a, err := agent.Find(r.PathValue("id"))
if err != nil {
fail(rw, err)
return
}
c, err := a.UpdateCLI()
if err != nil {
fail(rw, err)
return
}
writeJSON(rw, c)
})
// quits the agent's desktop app and opens it again, so it reads what
// magpie wrote: the row's Restart, after the user said yes to it
mux.HandleFunc("POST /api/agents/restart/{id}", func(rw http.ResponseWriter, r *http.Request) {
a, err := agent.Find(r.PathValue("id"))
if err != nil {
fail(rw, err)
return
}
ctx, cancel := context.WithTimeout(r.Context(), 2*time.Minute)
defer cancel()
if err := a.RestartApp(ctx); err != nil {
fail(rw, err)
return
}
writeJSON(rw, state())
})
// what disconnecting an agent changes in its files, line by line, for
// the dialog asking it (agent.DisconnectPreview); its files when the
// preview can't be had
mux.HandleFunc("GET /api/agents/preview/{id}", func(rw http.ResponseWriter, r *http.Request) {
a, err := agent.Find(r.PathValue("id"))
if err != nil {
fail(rw, err)
return
}
exe, err := os.Executable()
if err != nil {
fail(rw, err)
return
}
if a.Native != nil {
plan, err := a.Native.Disconnect()
if err != nil {
writeJSON(rw, map[string]any{"error": err.Error()})
return
}
writeJSON(rw, map[string]any{"changes": plan.Preview(), "revision": plan.Revision(a.ID)})
return
}
changes, err := agent.DisconnectPreview(a, exe)
out := map[string]any{"changes": changes}
if err != nil {
out["error"] = err.Error()
}
writeJSON(rw, out)
})
mux.HandleFunc("POST /api/agents/disconnect-offline/{id}", func(rw http.ResponseWriter, r *http.Request) {
a, err := agent.Find(r.PathValue("id"))
if err != nil {
fail(rw, err)
return
}
if a.Native == nil || a.Native.ExecuteOffline == nil {
fail(rw, fmt.Errorf("this agent does not support offline disconnect"))
return
}
var in struct {
Revision string `json:"revision"`
}
dec := json.NewDecoder(r.Body)
dec.DisallowUnknownFields()
if err := dec.Decode(&in); err != nil {
fail(rw, err)
return
}
plan, err := a.Native.Disconnect()
if err != nil {
fail(rw, err)
return
}
if in.Revision == "" || in.Revision != plan.Revision(a.ID) {
fail(rw, fmt.Errorf("Disconnect preview changed; preview it again"))
return
}
if err := a.Native.ExecuteOffline(plan); err != nil {
fail(rw, err)
return
}
writeJSON(rw, state())
})
mux.HandleFunc("POST /api/agents/{action}/{id}", func(rw http.ResponseWriter, r *http.Request) {
a, err := agent.Find(r.PathValue("id"))
if err != nil {
fail(rw, err)
return
}
var how *agent.Connection
switch r.PathValue("action") {
case "reapply":
err = a.Reapply()
case "keep":
a.Keep()
case "connect":
var c agent.Connection
c, err = a.ConnectHow()
how = &c
case "disconnect":
err = a.Disconnect()
default:
http.NotFound(rw, r)
return
}
if err != nil {
fail(rw, err)
return
}
s := state()
if a.Notice != nil {
s.Notice = a.Notice()
}
s.Connected = how
writeJSON(rw, s)
})
mux.HandleFunc("POST /api/profile/{action}", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Name string }
_ = json.NewDecoder(r.Body).Decode(&in)
in.Name = strings.TrimSpace(in.Name)
var err error
var applied profile.Applied
switch r.PathValue("action") {
case "save":
var p profile.Profile
if p, err = profile.Snapshot(); err == nil {
err = profile.Save(in.Name, p)
}
case "use":
var ps map[string]profile.Profile
if ps, err = profile.Load(); err == nil {
applied, err = profile.Apply(ps[in.Name])
}
if applied.Library != nil {
lastProblems.Lock()
lastProblems.p = applied.Library.Problems
lastProblems.Unlock()
}
case "delete":
err = profile.Delete(in.Name)
default:
http.NotFound(rw, r)
return
}
if err != nil {
fail(rw, err)
return
}
s := state()
writeJSON(rw, struct {
stateJSON
Changed int `json:"changed"`
// Library is what bringing the profile's library setup back did
Library *library.Result `json:"library,omitempty"`
}{s, applied.Changed, applied.Library})
})
mux.HandleFunc("POST /api/sync", func(rw http.ResponseWriter, r *http.Request) {
ctx, cancel := context.WithTimeout(r.Context(), 30*time.Second)
defer cancel()
if err := catalog.Sync(ctx); err != nil {
fail(rw, err)
return
}
for _, p := range provider.All() {
if p.Ready() {
c, cancel := context.WithTimeout(ctx, 8*time.Second)
p.Fetch(c)
cancel()
}
}
writeJSON(rw, state())
})
providerRoutes(mux, w)
importRoutes(mux)
usageRoutes(mux, w)
callerKeyRoutes(mux)
sessionRoutes(mux, w)
sessionManageRoutes(mux, w)
backupRoutes(mux, w)
uninstallRoutes(mux, w)
archiveRoutes(mux)
libraryRoutes(mux, w)
updateRoutes(mux, w)
whatsNewRoutes(mux)
cliBehindRoutes(mux)
configRepairRoutes(mux, !isWeb(w))
gatewayFixRoutes(mux)
gatewayModeRoutes(mux)
if !isWeb(w) {
appPageRoutes(mux)
}
privacyModelRoutes(mux)
maskingRoutes(mux)
builtinRoutes(mux)
mux.HandleFunc("GET /api/settings", func(rw http.ResponseWriter, r *http.Request) {
access.MigrateLegacyLANKeyBestEffort()
writeJSON(rw, settingsState())
})
mux.HandleFunc("POST /api/settings", func(rw http.ResponseWriter, r *http.Request) {
var body json.RawMessage
var in settings.Settings
if err := json.NewDecoder(r.Body).Decode(&body); err != nil {
fail(rw, err)
return
}
if err := json.Unmarshal(body, &in); err != nil {
fail(rw, err)
return
}
// the Settings page sends its own choices; how the agents are
// arranged is the Agents page's, and the window's size its own; both stay as they are.
// Unreadable settings are never carried as the defaults (an empty
// allow list, every address let in): Save would refuse them too.
cur, err := settings.LoadChecked()
if err != nil {
fail(rw, err)
return
}
var fields map[string]json.RawMessage
_ = json.Unmarshal(body, &fields)
// Older pages do not send fonts. An explicit null restores the
// default, while an omitted field (or a browser save) preserves it.
if _, sent := fields["uiFont"]; !sent || isWeb(w) {
in.UIFont = cur.UIFont
}
if _, sent := fields["codeFont"]; !sent || isWeb(w) {
in.CodeFont = cur.CodeFont
}
// and pages from before it do not send how often a refusal is asked
// again, which null sets back to every one left
if _, sent := fields["refusalRetries"]; !sent {
in.RefusalRetries = cur.RefusalRetries
}
// nor whether updates download by themselves (#2296)
if _, sent := fields["noAutoDownload"]; !sent {
in.NoAutoDownload = cur.NoAutoDownload
}
// nor the update channel (ssharpcc on X)
if _, sent := fields["updateChannel"]; !sent {
in.UpdateChannel = cur.UpdateChannel
}
// nor whether the masked words match in any case
if _, sent := fields["redactWordsAnyCase"]; !sent {
in.RedactWordsAnyCase = cur.RedactWordsAnyCase
}
// nor whether they match only as whole words
if _, sent := fields["redactWordsWhole"]; !sent {
in.RedactWordsWhole = cur.RedactWordsWhole
}
// nor whether a key goes as a made-up one of its form
if _, sent := fields["redactShape"]; !sent {
in.RedactShape = cur.RedactShape
}
// nor how long an image is given to be drawn
if _, sent := fields["imageTimeout"]; !sent {
in.ImageTimeout = cur.ImageTimeout
}
// nor how long a routing group's classifier is given (#2934)
if _, sent := fields["classifyTimeout"]; !sent {
in.ClassifyTimeout = cur.ClassifyTimeout
}
// nor whether animations are stilled (#3813)
if _, sent := fields["reduceMotion"]; !sent {
in.ReduceMotion = cur.ReduceMotion
}
// nor whether the loading bird is kept off
if _, sent := fields["noBird"]; !sent {
in.NoBird = cur.NoBird
}
// nor whether a value masked for the first time is told (Must2333)
if _, sent := fields["maskAlert"]; !sent {
in.MaskAlert = cur.MaskAlert
}
in.AgentOrder, in.AgentsHidden, in.AgentsShown = cur.AgentOrder, cur.AgentsHidden, cur.AgentsShown
in.Window, in.WindowMaximised = cur.Window, cur.WindowMaximised // the window's own, as it was last resized
// and what other pages keep here: which models an agent is shown, and
// everything the user said of a model anywhere else in the app, set on
// its own. The per-model maps are carried whole rather than named one
// by one, so a map added later is not silently dropped here.
//
// HiddenModels, PickedModels and OrderedModels are the other way
// round — keyed by agent, not by "<provider>/<model>" — so they are
// not among them, and belong to the Agents page.
in.Visible, in.HiddenModels, in.OrderedModels = cur.Visible, cur.HiddenModels, cur.OrderedModels
in.PickedModels = cur.PickedModels // "only models I pick" (#1337)
in.OwnModelsHidden = cur.OwnModelsHidden // an agent's own models left out (#1642)
in.FastPicks = cur.FastPicks // switched in the agents' pickers (#954)
in.UltraPicks = cur.UltraPicks // and sent Ultrafast (#1954)
in.AgentEfforts = cur.AgentEfforts // picked in an agent's row (#1003)
in.PluginCheckins = cur.PluginCheckins // set on its own (plugin-checkin below)
in.PluginOptions = cur.PluginOptions // set on its own (plugin-option below)
in.CheckinOff = cur.CheckinOff // set on its own (checkin-account below)
settings.CarryPerModel(&in, &cur)
in.LAN, in.LANKey = cur.LAN, cur.LANKey
in.LANKeyID = cur.LANKeyID
in.Port = cur.Port // set on its own (port below), which moves the gateway
in.CORSOrigins = cur.CORSOrigins // set on its own (cors below)
in.AllowIPs = cur.AllowIPs // set on its own (allowips below)
in.FetchPrivate = cur.FetchPrivate // in settings.json only
in.GitHubToken = cur.GitHubToken // set on its own (github-token below), never sent to the page
in.ProxyCustom = cur.ProxyCustom // set by settings.Save from the proxy, never by the page
in.RequestArchive = cur.RequestArchive // the Gateway page's, set on its own
in.RequestArchiveMaxMB = cur.RequestArchiveMaxMB // in settings.json only
in.ClaudeRunsMost = cur.ClaudeRunsMost // magpie claude-code runs, or settings.json (#2956)
in.GatewayConversations = cur.GatewayConversations // Sessions' explicit recording consent
in.RedactRules = cur.RedactRules // the masking rules, set on their own
in.RedactModel = cur.RedactModel // set on its own (privacy-model)
in.RedactModelName = cur.RedactModelName // set on its own (privacy-model)
in.RedactModelScore = cur.RedactModelScore // set on its own (privacy-model)
in.RedactModelOff = cur.RedactModelOff // set on its own (privacy-model)
in.RedactModelAuto = cur.RedactModelAuto // set on its own (masking)
in.RedactActions = cur.RedactActions // set on their own (redact-actions below)
in.RedactAllow = cur.RedactAllow // set on its own (redact-allow below)
in.DisabledModels = cur.DisabledModels // set on their own (disabled-models below, #1867)
// the request archive on this computer: the archive's switch while no
// S3 bucket, and its size in settings.json only
in.RequestArchiveLocal, in.RequestArchiveLocalMB = cur.RequestArchiveLocal, cur.RequestArchiveLocalMB
// used or left is the Usage page's toggle as much as Settings', set on its own
in.QuotaLeft = cur.QuotaLeft
in.QuotaReads = cur.QuotaReads // set on its own (quota-reads below)
in.UsageOrder = cur.UsageOrder // the Usage page's, dragged there
// and what the tray panel's Allowances tab leaves out, set there
in.PanelUsageHidden = cur.PanelUsageHidden
// and the clients the Usage page's Agents list leaves out, set there
in.UsageAgentsHidden = cur.UsageAgentsHidden
// and the allowance cards the Usage page's Overview leaves out, set there
in.UsageCardsHidden = cur.UsageCardsHidden
// and the names models' usage is counted under (magpie model alias)
in.UsageAliases = cur.UsageAliases
// and the clears of usage made on the Usage page
in.UsageCleared = cur.UsageCleared
// and the clients it counts as agents, set there too (#1958)
in.ClientAgents = cur.ClientAgents
// how agents' lists name models, set on its own for the agents to be told
in.PlainNames, in.PlainOwnNames = cur.PlainNames, cur.PlainOwnNames
in.BareModelIDs = cur.BareModelIDs // set on its own (bare-ids below)
in.CodexAgentsV1 = cur.CodexAgentsV1
in.FullContext = cur.FullContext // set on its own (full-context below)
in.CompactAt = cur.CompactAt // and so is the threshold
// Codex's background compaction, set on its own (codex-async-compact below)
in.CodexAsyncCompact, in.CodexAsyncCompactPercent = cur.CodexAsyncCompact, cur.CodexAsyncCompactPercent
// Claude Desktop's list, set in its row on the Agents page
in.DesktopLongest = cur.DesktopLongest
// and the Get started card put away, from the card itself
in.GuideHidden = cur.GuideHidden
in.CodexTitles = cur.CodexTitles // set on its own (codex-titles below)
in.CodexDescriptions = cur.CodexDescriptions // set on its own (codex-descriptions below)
in.CodexPredictions = cur.CodexPredictions // and codex-predictions
// and so is the model Codex's auto-review runs on (codex-auto-review)
in.CodexAutoReview = cur.CodexAutoReview
// and the models Codex's and Desktop's subagents are put on, set
// in their Agents rows
in.CodexSubagentModel = cur.CodexSubagentModel
in.DesktopSubagentModel = cur.DesktopSubagentModel
// and the model for requests masking would change (redact-route)
in.RedactRouteTo = cur.RedactRouteTo
in.DesktopSubagentEffort = cur.DesktopSubagentEffort
in.ChinaMirror = cur.ChinaMirror // the Plugins page's, set on its own
// which Codex accounts spend a reset by themselves, set on the Usage card
in.CodexAutoReset = cur.CodexAutoReset
in.CodexAutoResetOnly = cur.CodexAutoResetOnly // and at which of the two times
// and which of them spend their credits, set there too
in.CodexNoCredits = cur.CodexNoCredits
// and each Codex account's own daily warm-up (codex-warm-at below)
in.CodexWarmAtOf = cur.CodexWarmAtOf
// and the text size, which the keyboard changes too (text-size below)
in.TextSize = cur.TextSize
// the Dock choice's reading, which the page never sets: the file's
// as read (settings.DockSettled), so a save from the page doesn't
// read its With window as an older file's Hide
in.DockSettled = cur.DockSettled
// the version the Update pill was hidden for, set from the pill
in.UpdateSkip = cur.UpdateSkip
// the GitHub mirror updates come through, set by magpie update mirror
in.UpdateMirror = cur.UpdateMirror
// gateway mode, set on its own (gateway-mode)
in.GatewayMode = cur.GatewayMode
in.NoAccountDiscovery = cur.NoAccountDiscovery // set on its own (account-discovery below, or the CLI)
if v := strings.TrimSpace(in.Vision); v != "" && v != "off" && v != cur.Vision {
if _, _, ok := provider.Resolve(v); !ok {
fail(rw, fmt.Errorf("no model %s to describe images", v))
return
}
}
if v := strings.TrimSpace(in.ImageGen); v != "" && v != "off" && v != cur.ImageGen {
if _, _, ok := provider.Resolve(v); !ok {
fail(rw, fmt.Errorf("no model %s to generate images", v))
return
}
}
if v := strings.TrimSpace(in.Searcher); v != "" && v != "off" && v != cur.Searcher {
id, _, _ := strings.Cut(v, "/")
if !slices.ContainsFunc(gateway.Searchers(), func(c gateway.SearcherChoice) bool { return c.Provider.ID == id }) {
fail(rw, fmt.Errorf("%s can't search the web for other models", id))
return
}
}
if err := settings.Save(in); err != nil {
fail(rw, err)
return
}
if onFonts != nil && (!sameFont(in.UIFont, cur.UIFont) || !sameFont(in.CodeFont, cur.CodeFont)) {
onFonts()
}
// whether agents are told every model takes images follows Vision
// (provider.Described)
if strings.TrimSpace(in.Vision) != strings.TrimSpace(cur.Vision) {
catalog.Touched()
}
if (in.Dock != cur.Dock || in.DockWindow != cur.DockWindow || in.DockNever != cur.DockNever) && onDock != nil {
onDock(in)
}
// the cards the menu bar shows, any of them (TrayUsage is only the first),
// how often, with their logos or not, beside the bird or not, and
// with their Pace numbers or not, with magpie's totals' cost or not
if (!slices.Equal(settings.Load().TrayUsages, cur.TrayUsages) || in.TrayUsageEvery != cur.TrayUsageEvery ||
in.TrayNoLogos != cur.TrayNoLogos || in.TrayNoBird != cur.TrayNoBird || in.TrayPace != cur.TrayPace ||
in.TrayNoCost != cur.TrayNoCost) && onTrayUsage != nil {
onTrayUsage()
}
// an alert turned on or moved is looked at now, the Mac asked for its
// leave to notify as it is turned on (#368)
if (in.UsageAlert != cur.UsageAlert || in.BalanceAlert != cur.BalanceAlert || in.ResetReminder != cur.ResetReminder || in.TurnDoneAlert != cur.TurnDoneAlert || in.MaskAlert != cur.MaskAlert) &&
(in.UsageAlert > 0 || in.BalanceAlert > 0 || in.ResetReminder > 0 || in.TurnDoneAlert > 0 || in.MaskAlert) && onAlerts != nil {
onAlerts()
}
// the tray menu follows the page's language (#301)
if in.Lang != cur.Lang && onLang != nil {
onLang()
}
// an update check that failed, without the proxy set just now, is
// tried again through it, not in six hours (#294), and marked so
// before this answers: the page stops asking on the old error
if strings.TrimSpace(in.Proxy) != strings.TrimSpace(cur.Proxy) && updates.json().State == "error" && updates.begin() {
go updates.run()
}
// another update channel: the feed is asked again on it, so the
// version row and the header's Update follow (a download from
// every version is dropped on Stable, run), unless automatic
// updates are off and nothing was found
if in.UpdateChannel != cur.UpdateChannel && (!in.NoAutoUpdate || updates.json().Latest != "") && updates.begin() {
go updates.run()
}
writeJSON(rw, settingsState())
})
// whether usage reads as used or left: the Usage page's toggle and
// Settings', for every meter and the menu bar alike (#122)
mux.HandleFunc("POST /api/settings/quota-left", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ On bool }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
changed := s.QuotaLeft != in.On
s.QuotaLeft = in.On
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
if changed && onTrayUsage != nil {
onTrayUsage()
}
writeJSON(rw, settingsState())
})
// when allowances are read: whenever magpie needs them, or only when
// the user asks (#1518)
mux.HandleFunc("POST /api/settings/quota-reads", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Reads string `json:"reads"`
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
s.QuotaReads = in.Reads
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// whether agents' sign-ins are read and served as subscriptions
// (#1535): saved, the accounts read before are forgotten at once
mux.HandleFunc("POST /api/settings/account-discovery", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Off bool `json:"off"`
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
s.NoAccountDiscovery = in.Off
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
provider.ForgetAccounts()
writeJSON(rw, settingsState())
})
// the version the header's Update pill is hidden for, until a newer one
// is out: set from the pill, cleared ("") from Settings
mux.HandleFunc("POST /api/settings/update-skip", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Version string `json:"version"`
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
s.UpdateSkip = strings.TrimSpace(in.Version)
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// whether the agents' lists name a model with its provider's after it or
// alone (#335): their files are written again, and Codex asks again
mux.HandleFunc("POST /api/settings/plain-names", func(rw http.ResponseWriter, r *http.Request) {
// Mode is on, own (#92: not on the names the user gave) or off; a
// body of On alone is the two-way switch's, On meaning plain
var in struct {
On bool
Mode string
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
set := func() error { return provider.SetPlainNames(in.On) }
if in.Mode != "" {
set = func() error { return provider.SetSuffixMode(in.Mode) }
}
if err := set(); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// whether the gateway's /v1/models lists each model by its id without
// the provider as well (settings.BareModelIDs, love1sbug on X)
mux.HandleFunc("POST /api/settings/bare-ids", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ On bool }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
if err := provider.SetBareModelIDs(in.On); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// whether Codex's OpenAI models say multi-agent V1 (#141): Codex's lists
// are written again and asked for again
mux.HandleFunc("POST /api/settings/codex-agents-v1", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ On bool }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
if err := provider.SetCodexAgentsV1(in.On); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// the Agents page's Get started card put away, or back (GuideHidden)
mux.HandleFunc("POST /api/settings/guide", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Hidden bool }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
s.GuideHidden = in.Hidden
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// whether Claude Desktop lists a model of 1M or more once, by its 1M id
// (settings.DesktopLongest, #1272): it reads the list as it starts
mux.HandleFunc("POST /api/settings/desktop-longest", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ On bool }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
was := s.DesktopLongest
s.DesktopLongest = in.On
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
// a model listed by its 1M id leaves the window Claude Code is
// told for Desktop's others, or joins it (#1458)
if was != in.On {
catalog.Touched()
}
writeJSON(rw, settingsState())
})
// whether Codex and Claude Code are told a model's whole context window
// or the working one (settings.FullContext): their lists are written
// again
mux.HandleFunc("POST /api/settings/full-context", func(rw http.ResponseWriter, r *http.Request) {
// At, when given, is a threshold to compact at instead, in
// tokens: 0 is the working window again (#876)
var in struct {
On bool
At *int
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
err := provider.SetFullContext(in.On)
if err == nil && !in.On && in.At != nil {
err = provider.SetCompactAt(*in.At)
}
if err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// Codex's background compaction (#2490): on or off, and the share of
// a model's window it starts at (0: Codex's own, 65), written into the
// config Codex is routed through
mux.HandleFunc("POST /api/settings/codex-async-compact", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
On bool
Percent *int
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
pct := settings.Load().CodexAsyncCompactPercent
if in.Percent != nil {
pct = *in.Percent
}
if err := provider.SetCodexAsyncCompact(in.On, pct); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// where Codex's request for a thread's description goes: "" as Codex
// sends it, "off", or a model's id. It is separate from the title
// setting.
mux.HandleFunc("POST /api/settings/codex-descriptions", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Model string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
v := strings.TrimSpace(in.Model)
if v != "" && v != "off" {
if _, _, ok := provider.Resolve(v); !ok {
fail(rw, fmt.Errorf("no model %s to write Codex's descriptions", v))
return
}
}
s := settings.Load()
s.CodexDescriptions = v
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// where the Codex app's request to predict the user's next message
// goes (#1970): "" as Codex sends it, "off", or a model's id
mux.HandleFunc("POST /api/settings/codex-predictions", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Model string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
v := strings.TrimSpace(in.Model)
if v != "" && v != "off" {
if _, _, ok := provider.Resolve(v); !ok {
fail(rw, fmt.Errorf("no model %s to write Codex's composer predictions", v))
return
}
}
s := settings.Load()
s.CodexPredictions = v
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// where Codex's requests for a thread's title go (#705): "" as Codex
// sends them, "off", or a model's id
// the models turned off for every request through magpie (#1867), each
// an id or a glob, the list sent whole
mux.HandleFunc("POST /api/settings/disabled-models", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Models []string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
if err := provider.SetDisabledModels(in.Models); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// Settings › Proxy's Test (#2076): the address Cloudflare sees a request
// from through the proxy in force, and without it
mux.HandleFunc("POST /api/proxy/check", handleProxyCheck)
mux.HandleFunc("POST /api/settings/codex-titles", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Model string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
v := strings.TrimSpace(in.Model)
if v != "" && v != "off" {
if _, _, ok := provider.Resolve(v); !ok {
fail(rw, fmt.Errorf("no model %s to write Codex's titles", v))
return
}
}
s := settings.Load()
s.CodexTitles = v
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// the model an agent's request masking would change goes to as
// written (jessyoungyu on X): "" masks it as before; else a model whose
// every route the user set to go unmasked (gateway.MaskRoute)
mux.HandleFunc("POST /api/settings/redact-route", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Model string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
v := strings.TrimSpace(in.Model)
if v != "" && !gateway.MaskRoute(v) {
fail(rw, fmt.Errorf("%s can't take requests unmasked: pick a model on this computer or your network whose provider is set to Send requests unmasked, with no fallback elsewhere", v))
return
}
s := settings.Load()
s.RedactRouteTo = v
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// the model Codex's auto-review runs on (#938): "" as Codex picks it,
// or a model's id, named in every entry of Codex's list
mux.HandleFunc("POST /api/settings/codex-auto-review", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Model string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
v := strings.TrimSpace(in.Model)
if v != "" && v != settings.CodexAutoReviewSession {
// Resolve intentionally accepts arbitrary names under a known
// provider. An approval reviewer must be a model or group magpie
// actually lists, including providers kept unlisted for routing.
if !slices.ContainsFunc(provider.Served(), func(e provider.Entry) bool { return e.ID == v || e.Group != "" && provider.SameRef(e.ID, v) }) {
fail(rw, fmt.Errorf("no model %s for Codex's auto-review", v))
return
}
}
if err := provider.SetCodexAutoReview(v); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// Warm up now: one Codex or Claude account's warm-up sent at once, and
// why it failed
mux.HandleFunc("POST /api/warm-now", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Agent, User string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
if err := provider.WarmNow(r.Context(), in.Agent, in.User); err != nil {
fail(rw, err)
return
}
writeJSON(rw, map[string]bool{"ok": true})
})
// whether a Codex account spends one of its resets by itself once its
// week is used up, the Usage card's toggle, set on its own
// a Codex account's own daily warm-up time: "06:00", "off", or "" to
// follow the one for all (#957)
mux.HandleFunc("POST /api/settings/codex-warm-at", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ User, At string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
if err := provider.SetCodexWarmAt(in.User, in.At); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// a Codex account's auto-use of its resets: at both times, or with When
// ("week" or "expiring") at that one alone, the other kept (#2078)
mux.HandleFunc("POST /api/settings/codex-auto-reset", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
User string
On bool
When string
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
if strings.TrimSpace(in.User) == "" {
fail(rw, fmt.Errorf("which Codex account?"))
return
}
set := func() error { return provider.SetCodexAutoReset(in.User, in.On) }
if in.When != "" {
set = func() error { return provider.SetCodexAutoResetCase(in.User, in.When, in.On) }
}
if err := set(); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// whether a Codex account spends its credits once its allowance is
// used up, the Usage card's toggle, set on its own
mux.HandleFunc("POST /api/settings/codex-credits", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
User string
On bool
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
if strings.TrimSpace(in.User) == "" {
fail(rw, fmt.Errorf("which Codex account?"))
return
}
if err := provider.SetCodexCredits(in.User, in.On); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// whether WorkBuddy's daily check-in is pressed each day, the Usage
// card's toggle (#694), set on its own as Settings' is
mux.HandleFunc("POST /api/settings/workbuddy-checkin", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ On bool }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
s.WorkBuddyCheckin = in.On
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// and Trae CN's (#694)
mux.HandleFunc("POST /api/settings/trae-checkin", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ On bool }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
s.TraeCheckin = in.On
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// and MiniMax Code's (#811)
mux.HandleFunc("POST /api/settings/minimax-checkin", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ On bool }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
s.MiniMaxCheckin = in.On
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// and Qoder's daily credits
mux.HandleFunc("POST /api/settings/qoder-checkin", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ On bool }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
s.QoderCheckin = in.On
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// and a plugin's own daily check-in, by its provider
mux.HandleFunc("POST /api/settings/plugin-checkin", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Provider string
On bool
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
if in.Provider == "" {
fail(rw, errors.New("no provider"))
return
}
s := settings.Load()
s.PluginCheckins = maps.Clone(s.PluginCheckins)
if s.PluginCheckins == nil {
s.PluginCheckins = map[string]bool{}
}
s.PluginCheckins[in.Provider] = in.On
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// and a switch a plugin declares for its provider (auth.options, #2038),
// by the plugin's own provider id, handed to the running host at once
mux.HandleFunc("POST /api/settings/plugin-option", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Provider string
Key string
On bool
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
if in.Provider == "" || !pluginOptionKey.MatchString(in.Key) {
fail(rw, errors.New("no provider or no such option"))
return
}
s := settings.Load()
s.PluginOptions = maps.Clone(s.PluginOptions)
if s.PluginOptions == nil {
s.PluginOptions = map[string]map[string]bool{}
}
own := maps.Clone(s.PluginOptions[in.Provider])
if own == nil {
own = map[string]bool{}
}
own[in.Key] = in.On
s.PluginOptions[in.Provider] = own
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
// best effort: a host that misses it reads them when it next starts
ctx, cancel := context.WithTimeout(r.Context(), 5*time.Second)
_ = plugin.SetProviderOptions(ctx)
cancel()
writeJSON(rw, settingsState())
})
// and one account's daily check-in, whichever vendor's (#1902): off
// leaves it out while its vendor's is on
mux.HandleFunc("POST /api/settings/checkin-account", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Key string
On bool
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
if in.Key == "" {
fail(rw, errors.New("no account"))
return
}
s := settings.Load()
off := slices.DeleteFunc(slices.Clone(s.CheckinOff), func(k string) bool { return k == in.Key })
if !in.On {
off = append(off, in.Key)
}
if len(off) == 0 {
off = nil
}
s.CheckinOff = off
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// how large the window and the panel are drawn: Settings' choice and
// Ctrl/Cmd +, − and 0 in either, set on its own so a key pressed while
// the Settings page saves something else is never undone by it
mux.HandleFunc("POST /api/settings/text-size", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Size int }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
s.TextSize = in.Size
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
if w != nil {
w.SetTextSize(in.Size)
}
writeJSON(rw, settingsState())
})
// the Agents page's order and what it folds away, in magpie's settings
mux.HandleFunc("POST /api/agents/arrange", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Order, Hidden, Shown []string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
s.AgentOrder, s.AgentsHidden, s.AgentsShown = in.Order, in.Hidden, in.Shown
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// the Usage page's order of its cards, which the tray panel's Allowances
// tab follows, what that tab leaves out, the clients the page's Agents
// list leaves out, the allowance cards its Overview leaves out
// (CardsHidden), and a client it counts as one of the agents (Count,
// #1958; As "" counts it on its own again), in magpie's settings; one
// not sent stays as it is
mux.HandleFunc("POST /api/usage/arrange", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Order *[]string
PanelHidden *[]string
AgentsHidden *[]string
CardsHidden *[]string
Count *struct{ Client, As string }
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
if in.Count != nil {
m, err := countClient(s.ClientAgents, in.Count.Client, in.Count.As)
if err != nil {
fail(rw, err)
return
}
s.ClientAgents = m
}
if in.Order != nil {
s.UsageOrder = *in.Order
}
if in.PanelHidden != nil {
s.PanelUsageHidden = *in.PanelHidden
}
if in.AgentsHidden != nil {
s.UsageAgentsHidden = *in.AgentsHidden
}
if in.CardsHidden != nil {
s.UsageCardsHidden = *in.CardsHidden
}
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
mux.HandleFunc("POST /api/settings/login", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ On bool }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
if err := autostart.Set(in.On); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// Sharing controls exposure; the gateway's named caller keys authenticate
// remote clients just as they do local ones.
mux.HandleFunc("POST /api/settings/lan", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ On, NewKey bool }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
// the agents reaching the gateway now: one in a WSL distro under NAT
// is given the sharing key, which this changes
on := agent.OnGateway()
if err := access.ConfigureLAN(in.On, in.NewKey); err != nil {
fail(rw, err)
return
}
if gw := served.Load(); gw != nil {
if err := gw.Relisten(); err != nil {
fail(rw, err)
return
}
}
out := settingsState()
if _, err := agent.Rekey(on); err != nil {
out.Rekeyed = err.Error()
}
writeJSON(rw, out)
})
// the web pages that may call the gateway from a browser (#1051), as
// their origins; none takes them all away
mux.HandleFunc("POST /api/settings/cors", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Origins []string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
origins, err := settings.CleanOrigins(in.Origins)
if err != nil {
fail(rw, err)
return
}
s := settings.Load()
s.CORSOrigins = origins
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// the allow list (lc on Discord): the addresses other computers may
// reach magpie from, as IPs and CIDR ranges; none lets every address in.
// One that would shut out the page saving it (magpie web, opened from
// another computer) is refused, and so is any while MAGPIE_ALLOW_IPS
// sets the list.
mux.HandleFunc("POST /api/settings/allowips", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ IPs []string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
if _, env := gateway.AllowIPs(); env {
fail(rw, fmt.Errorf("%s sets the allow list; change it there", gateway.AllowIPsEnv))
return
}
list, err := settings.CleanAllowIPs(in.IPs)
if err != nil {
fail(rw, err)
return
}
if addr, out := gateway.KeepsOut(list, r); out {
fail(rw, fmt.Errorf("that allow list would shut out %s, the address this page is open from: add it first", addr))
return
}
s, err := settings.LoadChecked()
if err != nil {
fail(rw, err)
return
}
s.AllowIPs = list
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// the gateway's port (Magic_zero on Discord), set on its own: it moves
// the gateway and every agent connected to it
mux.HandleFunc("POST /api/settings/port", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Port int }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
res, err := setPort(in.Port)
if err != nil {
fail(rw, err)
return
}
writeJSON(rw, map[string]any{"settings": settingsState(), "port": res})
})
// the user's own masking rules, all of them each time: set on their own,
// so a pattern that doesn't compile is said and the rest are kept (#195)
mux.HandleFunc("POST /api/settings/redact-rules", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Rules []redact.Rule }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
s.RedactRules = in.Rules
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// one masking rule changed in place (nf1qaz2w on Discord): the rule at
// At, which must still be Was, becomes Rule, checked as an added one is.
// A rule that can't be used is said and every rule is kept as it was.
mux.HandleFunc("POST /api/settings/redact-rule", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
At int `json:"at"`
Was redact.Rule `json:"was"`
Rule redact.Rule `json:"rule"`
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
next, err := editRedactRule(s.RedactRules, in.At, in.Was, in.Rule)
if err != nil {
fail(rw, err)
return
}
s.RedactRules = next
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// what is done with a value of a kind found, other than masking it
// (warn, block), all of them each time (#1977)
mux.HandleFunc("POST /api/settings/redact-actions", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Actions map[string]string `json:"actions"`
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
s.RedactActions = in.Actions
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// the values masking lets go as written, all of them each time (#1977)
mux.HandleFunc("POST /api/settings/redact-allow", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Allow []string `json:"allow"`
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
s := settings.Load()
s.RedactAllow = in.Allow
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// the GitHub token the library's requests to GitHub carry: set, or
// taken away with ""
mux.HandleFunc("POST /api/settings/github-token", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Token string `json:"token"`
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
tok := strings.TrimSpace(in.Token)
if strings.ContainsFunc(tok, func(c rune) bool { return c <= ' ' || c == 0x7f }) {
fail(rw, fmt.Errorf("a GitHub token is one word, without spaces"))
return
}
s := settings.Load()
s.GitHubToken = tok
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// the GitHub download mirror updates come through (#893), the same
// setting `magpie update mirror` sets: a full https:// prefix, or ""
// for GitHub itself. The feed and its checksums are never the mirror's.
mux.HandleFunc("POST /api/settings/update-mirror", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Mirror string `json:"mirror"`
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
m := strings.TrimSpace(in.Mirror)
if m != "" {
if err := update.CheckMirrorURL(m); err != nil {
fail(rw, err)
return
}
}
s := settings.Load()
s.UpdateMirror = m
if err := settings.Save(s); err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// a web search API added, given a new key or address, switched on or
// off, or taken away; or the APIs put in a new order (#2286)
mux.HandleFunc("POST /api/settings/search-api", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Vendor, Key, URL, Pick string
Remove bool
On *bool
Arrange []string
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
var err error
switch {
case in.Arrange != nil:
err = provider.ArrangeSearchAPIs(in.Arrange)
case in.Remove:
err = provider.RemoveSearchAPI(in.Vendor)
case in.On != nil:
err = provider.SwitchSearchAPI(in.Vendor, *in.On)
default:
err = provider.SetSearchAPI(provider.SearchAPI{Vendor: in.Vendor, Key: in.Key, URL: in.URL, Pick: in.Pick})
}
if err != nil {
fail(rw, err)
return
}
writeJSON(rw, settingsState())
})
// a search API's saved key, for its row's Show button (OnurBen on
// Discord); like a provider's, it never leaves this machine
mux.HandleFunc("POST /api/settings/search-key", func(rw http.ResponseWriter, r *http.Request) {
var in struct{ Vendor string }
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
for _, a := range provider.StoredSearchAPIs() {
if a.Vendor == in.Vendor {
writeJSON(rw, map[string]string{"key": a.Key})
return
}
}
fail(rw, fmt.Errorf("no search API %q", in.Vendor))
})
// what each of a search API's keys has used of its limit (SlouchyQuill
// on Discord), the keys masked; fresh reads again what was read lately
mux.HandleFunc("POST /api/settings/search-quota", func(rw http.ResponseWriter, r *http.Request) {
var in struct {
Vendor string
Fresh bool
}
if err := json.NewDecoder(r.Body).Decode(&in); err != nil {
fail(rw, err)
return
}
for _, a := range provider.StoredSearchAPIs() {
if a.Vendor == in.Vendor {
qs := gateway.SearchQuotas(r.Context(), a, in.Fresh)
if qs == nil {
qs = []gateway.SearchKeyQuota{}
}
writeJSON(rw, map[string]any{"keys": qs})
return
}
}
fail(rw, fmt.Errorf("no search API %q", in.Vendor))
})
// the config folder only: the page names no path, so it can't open others
mux.HandleFunc("POST /api/settings/reveal", func(rw http.ResponseWriter, r *http.Request) {
if err := w.OpenFolder(settings.Dir()); err != nil {
fail(rw, err)
return
}
rw.WriteHeader(http.StatusNoContent)
})
// the folder of the reports saved of requests held too long before
// routing (gateway.HeldDir), from such a request's row on Routing
mux.HandleFunc("POST /api/gateway/held/reveal", func(rw http.ResponseWriter, r *http.Request) {
dir := gateway.HeldDir()
if err := os.MkdirAll(dir, 0o700); err != nil {
fail(rw, err)
return
}
if err := w.OpenFolder(dir); err != nil {
fail(rw, err)
return
}
rw.WriteHeader(http.StatusNoContent)
})
mux.HandleFunc("POST /api/window/{action}", func(rw http.ResponseWriter, r *http.Request) {
switch r.PathValue("action") {
case "hide":
w.HidePanel()
case "main":
w.ShowMain(mainView(r.URL.Query()))
case "quit":
w.Quit()
case "fit":
if h, g, ok := parseFit(r.URL.Query()); ok {
w.FitPanel(h, g)
}
case "tint":
if c, ms, ok := parseTint(r.URL.Query()); ok && w.TintPanel(c, ms) {
writeJSON(rw, map[string]bool{"ok": true})
return
}
case "titlebar":
if c, _, ok := parseTint(r.URL.Query()); ok && w.TintTitleBar(c, r.URL.Query().Get("dark") == "1") {
writeJSON(rw, map[string]bool{"ok": true})
return
}
}
rw.WriteHeader(http.StatusNoContent)
})
agentModelsAPI(mux)
speedsAPI(mux)
devListen(mux)
return noFramedAPI(held(mux))
}
// noFramedAPI turns away a request for /api that no page of the window's
// own makes (apiFramed): a plugin's page in its frame among them.
func noFramedAPI(h http.Handler) http.Handler {
return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
if apiFramed(r) {
http.Error(rw, "magpie's API answers magpie's own window only", http.StatusForbidden)
return
}
h.ServeHTTP(rw, r)
})
}
// held has a page's reads share one build of the catalog, which every row
// resolving its model rebuilt (provider.Hold): /api/state took 4s with a
// few hundred models. A write shares it too: a save answers with the whole
// state it wrote — every group's members, every model's facts — and that
// was a build per look-up, seconds on a slow disk. The write's own
// catalog.Touched drops what is held as it happens, so the answer is never
// what was read before it, and the request leaves nothing held for the next.
func held(h http.Handler) http.Handler {
return http.HandlerFunc(func(rw http.ResponseWriter, r *http.Request) {
api := strings.HasPrefix(r.URL.Path, "/api/")
if api {
defer provider.Hold()()
// and the files read, not looked at again for each look-up
defer filememo.Hold()()
}
if strings.HasPrefix(r.URL.Path, "/api/sessions") || strings.HasPrefix(r.URL.Path, "/api/usage") {
// a page waits on the session files: the warm-up reading
// them reads at full speed meanwhile
defer sessions.Ask()()
// and what the read threw away goes back once the page rests
defer readingPage()()
// and collected under GOGC 25 while it runs: a poll's reads
// allocated ~330 MB to keep ~105 MB, and at the default 100 the
// heap grew to twice what it kept before a collection, ~320 MB
// in Activity Monitor during a poll. No memory limit: held as
// close as what Go held, every poll collected over and over,
// 5x the CPU.
defer tightenGC()()
}
if !(api && r.Method == http.MethodGet) {
// anything that may have written drops what was held, once it
// has answered with it
defer provider.Changed()
}
h.ServeHTTP(rw, r)
})
}
func state() stateJSON {
s := stateJSON{Agents: []agentJSON{}, Profiles: []profileJSON{}, Catalog: catalog.Source(), Settings: settings.Load()}
// state() is asked for after nearly every click, so the rate — a
// network fetch once every TTL — is only worth its rare latency when
// cny is actually chosen; usd never looks at it
if s.Settings.Currency == "cny" {
s.FX = currentFX()
}
s.Unlisted = unlistedModels()
s.CLIBehind = cliBehind()
s.ConfigBlocked = configBlocked()
for _, e := range provider.Served() {
if e.Group == "" {
s.Served++
}
}
for _, a := range agent.Clients() {
s.Clients = append(s.Clients, clientJSON{ID: a.ID, Name: a.Name, Icon: a.Icon})
}
detected := agent.Detected()
now := make(map[string]map[string]string, len(detected))
for _, a := range detected {
if a.Follow != nil {
_ = a.Follow()
}
vals := a.Values()
now[a.ID] = vals
aj := agentJSON{ID: a.ID, Name: a.Name, Icon: a.Icon, Path: tilde(a.Path), Fields: agentFields(a, vals)}
aj.Models = agentModelCount(a, aj.Fields)
aj.Menu = a.ListsModels
aj.NoNames = a.NoNames
aj.Drift = a.Drift()
aj.Wired = a.Wired()
if aj.Wired {
aj.StaleCopies = a.StaleCopies()
aj.Stale = len(aj.StaleCopies)
aj.Joined = a.Joined != nil && a.Joined()
if a.AppOut != nil && a.AppOut() {
aj.AppOut = codexAppOut()
}
} else {
aj.Source = a.Source()
aj.Failover = a.FailingOver != nil && a.FailingOver()
}
aj.AppRestart = a.AppBehind()
if a.Import != nil {
aj.Import = a.Import()
if a.Added != nil {
if added, known := a.Added(); known {
aj.Added = &added
}
}
}
if a.Launch != nil {
aj.Launch = a.Launch()
}
if a.Typed != nil && aj.Launch != "" {
aj.Typed = a.Typed()
}
aj.CLIMissing = a.CLIMissing()
if a.Native != nil {
native := a.Native.Read()
aj.Native = &native
}
s.Agents = append(s.Agents, aj)
}
if ps, err := profile.Load(); err == nil {
for _, n := range profile.Names(ps) {
pj := profileJSON{Name: n, Summary: profile.Summary(ps[n]), Agents: profile.Details(ps[n]), InUse: profile.InUse(ps[n], detected, now)}
if l := ps[n].Library; l != nil {
servers, skills := l.On()
pj.Library = &profileLibraryJSON{Servers: servers, Skills: skills, Instructions: l.GivesInstructions()}
}
s.Profiles = append(s.Profiles, pj)
}
}
s.Recovered = lastgood.Recovered()
return s
}
// signInOpened is a sign-in as it starts, with why its page didn't open in
// the browser: the window then shows the link to open by hand, instead of
// waiting on a page that never opened until the sign-in times out (#2043).
type signInOpened struct {
provider.SignInState
OpenError string `json:"openError,omitempty"`
}
// mcpSignInOpened is signInOpened for a sign-in to an MCP server.
type mcpSignInOpened struct {
mcpauth.State
OpenError string `json:"openError,omitempty"`
}
// openError opens url in the browser, and says why it didn't open: "" when
// it did, or when there is no url.
func openError(w Windows, url string) string {
if url == "" {
return ""
}
if err := w.OpenURL(url); err != nil {
return err.Error()
}
return ""
}
func writeJSON(rw http.ResponseWriter, v any) {
rw.Header().Set("Content-Type", "application/json")
_ = json.NewEncoder(rw).Encode(v)
}
// writeJSONSame is writeJSON for a read the page asks for again and again:
// the answer's X-Magpie-Tag is a hash of its bytes, and a request whose
// X-Magpie-Had is that tag gets X-Magpie-Same and no body, which the page
// reads as the answer it has (api in app.js). The Sessions tab read a long
// history's ~8 MB list and ~0.7 MB of stats every 15 s, and parsed and
// compared them whole to find them the same. Not an ETag and a 304:
// WebView2 is sent no If-None-Match, and Wails turns its 304 into a 505.
// It returns the tag, or "" when v could not be written.
func writeJSONSame(rw http.ResponseWriter, r *http.Request, v any) string {
var b bytes.Buffer
if err := json.NewEncoder(&b).Encode(v); err != nil {
fail(rw, err)
return ""
}
sum := sha256.Sum256(b.Bytes())
tag := hex.EncodeToString(sum[:16])
rw.Header().Set("X-Magpie-Tag", tag)
if r.Header.Get("X-Magpie-Had") == tag {
rw.Header().Set("X-Magpie-Same", "1")
rw.WriteHeader(http.StatusOK)
return tag
}
rw.Header().Set("Content-Type", "application/json")
_, _ = rw.Write(b.Bytes())
return tag
}
// sentRows is each row's hash in the last few lists writeJSONRows sent, by
// the answer's tag, oldest first: a few, for a window and a browser tab or
// two asking at once.
var sentRows struct {
sync.Mutex
tags []string
rows map[string][][16]byte
}
const sentRowsKept = 4
// rowsSize is the size of the last answer writeJSONRows wrote of each key,
// what the next one's buffer is made for.
var rowsSize sync.Map
// writeJSONRows is writeJSONSame for an answer that is a long list, key,
// beside the fields of rest: one asked with the tag of a list sent before
// that changed since gets X-Magpie-Delta: key, and its list holds only the
// rows not in that one, each run of rows that was, in its order, written
// [from, count] of the list the page has. While an agent works, its
// session's row changes every poll, and the Sessions tab read all ~5000
// rows (~8 MB) again for it.
func writeJSONRows[T any](rw http.ResponseWriter, r *http.Request, key string, rows []T, rest any) {
tail, err := json.Marshal(rest)
if err != nil {
fail(rw, err)
return
}
k, _ := json.Marshal(key)
// the rows are written once, into the answer itself: each row's
// Marshal, their Join and the answer's buffer were three copies of the
// ~8 MB list a poll, and the buffer grew to it from nothing
var whole bytes.Buffer
if n, ok := rowsSize.Load(key); ok {
whole.Grow(n.(int) + n.(int)/8)
}
whole.WriteByte('{')
whole.Write(k)
whole.WriteString(":[")
enc := json.NewEncoder(&whole)
ends := make([]int, len(rows)+1)
ends[0] = whole.Len()
for i := range rows {
if err := enc.Encode(rows[i]); err != nil {
fail(rw, err)
return
}
// Encode ends the row with a newline: it is the comma after it
whole.Bytes()[whole.Len()-1] = ','
ends[i+1] = whole.Len()
}
if len(rows) > 0 {
whole.Truncate(whole.Len() - 1)
}
end := func(b *bytes.Buffer) {
b.WriteByte(']')
if len(tail) > 2 {
b.WriteByte(',')
b.Write(tail[1:])
} else {
b.WriteByte('}')
}
b.WriteByte('\n')
}
end(&whole)
rowsSize.Store(key, whole.Len())
all := whole.Bytes()
raw := make([][]byte, len(rows))
sums := make([][16]byte, len(rows))
for i := range rows {
raw[i] = all[ends[i] : ends[i+1]-1]
sum := sha256.Sum256(raw[i])
sums[i] = [16]byte(sum[:16])
}
body := func(items [][]byte) []byte {
var b bytes.Buffer
b.WriteByte('{')
b.Write(k)
b.WriteString(":[")
b.Write(bytes.Join(items, []byte(",")))
end(&b)
return b.Bytes()
}
sum := sha256.Sum256(all)
tag := hex.EncodeToString(sum[:16])
rw.Header().Set("X-Magpie-Tag", tag)
had := r.Header.Get("X-Magpie-Had")
if had == tag {
rw.Header().Set("X-Magpie-Same", "1")
rw.WriteHeader(http.StatusOK)
return
}
sentRows.Lock()
was, ok := sentRows.rows[had]
if _, kept := sentRows.rows[tag]; !kept {
if sentRows.rows == nil {
sentRows.rows = map[string][][16]byte{}
}
if len(sentRows.tags) == sentRowsKept {
delete(sentRows.rows, sentRows.tags[0])
sentRows.tags = sentRows.tags[1:]
}
sentRows.tags = append(sentRows.tags, tag)
sentRows.rows[tag] = sums
}
sentRows.Unlock()
rw.Header().Set("Content-Type", "application/json")
if !ok || had == "" {
_, _ = rw.Write(all)
return
}
at := make(map[[16]byte][]int, len(was))
for j, s := range was {
at[s] = append(at[s], j)
}
var items [][]byte
from, n := 0, 0
run := func() {
if n > 0 {
items = append(items, []byte("["+strconv.Itoa(from)+","+strconv.Itoa(n)+"]"))
}
n = 0
}
for i, s := range sums {
js := at[s]
if len(js) == 0 {
run()
items = append(items, raw[i])
continue
}
j := js[0]
at[s] = js[1:]
if n > 0 && j == from+n {
n++
continue
}
run()
from, n = j, 1
}
run()
rw.Header().Set("X-Magpie-Delta", key)
_, _ = rw.Write(body(items))
}
func fail(rw http.ResponseWriter, err error) {
rw.Header().Set("Content-Type", "application/json")
rw.WriteHeader(http.StatusBadRequest)
out := map[string]string{"error": err.Error()}
var unavailable *agent.RuntimeUnavailableError
if errors.As(err, &unavailable) {
out["code"] = "runtime_unavailable"
out["offline"] = string(unavailable.Offline)
}
// an app's import link that nothing here opens, or that opens a
// program which is gone, said in the reader's language
var noHandler *agent.NoLinkHandlerError
if errors.As(err, &noHandler) {
out["code"], out["app"], out["exe"], out["said"] = "no_link_handler", noHandler.App, noHandler.Exe, linkSaid[noHandler.Exe != ""]
}
// a save refused because a folder on the way to magpie's own isn't the
// user's: the window offers to make it theirs again
if permissionDenied(err) {
if b := configBlocked(); b != "" {
out["code"], out["blocked"] = "config_blocked", b
}
}
var noModels *agent.NoModelsError
if errors.As(err, &noModels) {
out["code"] = "no_models"
out["agent"] = noModels.Agent
}
// magpie has models, and none is left in the agent's lists (#1989)
var allHidden *agent.AllHiddenError
if errors.As(err, &allHidden) {
out["code"] = "all_hidden"
out["agent"] = allHidden.Agent
}
var signedIn *provider.SignedInError
if errors.As(err, &signedIn) {
out["code"], out["agent"], out["user"] = "signed_in", signedIn.Agent, signedIn.User
}
// a text that isn't a group to import (laincatx on X), said in the
// reader's language
var share *provider.ShareError
if errors.As(err, &share) {
out["code"], out["share"] = "share", share.Why
out["format"], out["models"] = strconv.Itoa(share.Format), strings.Join(share.Models, ", ")
}
// an agent's npm update, or RTK's winget, that needed an administrator
// and didn't get one, said in the reader's language
var admin *agent.AdminError
if errors.As(err, &admin) {
out["code"], out["agent"], out["prefix"], out["command"], out["via"] = "needs_admin", admin.Agent, admin.Prefix, admin.Command, admin.Via
if admin.Canceled {
out["canceled"] = "1"
} else if admin.Err != nil {
out["reason"] = admin.Err.Error()
}
}
// a bun this Windows or processor can't run at all: said, with what
// to do, in the reader's language (zgcwkj on Discord)
var bun *plugin.BunUnstartableError
if errors.As(err, &bun) {
out["code"], out["bun"], out["bunWhy"] = "bun_unstartable", bun.Bun, bun.Why
out["said"] = bunSaid[bun.Why]
}
_ = json.NewEncoder(rw).Encode(out)
}
func tilde(p string) string {
if home, err := os.UserHomeDir(); err == nil && strings.HasPrefix(p, home) {
return "~" + p[len(home):]
}
return p
}
// loginUsers is agent's accounts signed in, by name, each once.
func loginUsers(agent string) []string {
var out []string
for _, l := range provider.Logins(agent) {
if l.User != "" && !slices.ContainsFunc(out, func(u string) bool { return strings.EqualFold(u, l.User) }) {
out = append(out, l.User)
}
}
return out
}
// editRedactRule is rules with the one at at, which must still be was,
// changed to to: tidied and checked as an added rule is, in the same place.
// It is refused when that rule is no longer there (changed or removed
// meanwhile), when to has neither a prefix nor a pattern (taking a rule
// away is Remove), and when to is another rule already listed.
func editRedactRule(rules []redact.Rule, at int, was, to redact.Rule) ([]redact.Rule, error) {
if at < 0 || at >= len(rules) || rules[at] != was {
return nil, fmt.Errorf("that masking rule is no longer there: it was changed or removed meanwhile")
}
tidy, err := redact.CheckRules([]redact.Rule{to})
if err != nil {
return nil, err
}
if len(tidy) == 0 {
return nil, fmt.Errorf("a masking rule needs a prefix or a regular expression")
}
for i, o := range rules {
if i != at && o == tidy[0] {
return nil, fmt.Errorf("the masking rule %s is there already", o.Kind)
}
}
next := slices.Clone(rules)
next[at] = tidy[0]
return next, nil
}
// countClient is the user's ClientAgents with client counted as the agent
// as (#1958), or on its own again when as is "". Only a client magpie
// doesn't know is counted as another, and only as an agent it knows: an
// agent counted as another would be lost from its own row, and magpie's
// own calls are kept apart from the agents' (#1839).
func countClient(m map[string]string, client, as string) (map[string]string, error) {
client, as = strings.TrimSpace(client), strings.TrimSpace(as)
if client == "" {
return nil, fmt.Errorf("no client to count")
}
out := maps.Clone(m)
if out == nil {
out = map[string]string{}
}
if as == "" {
delete(out, strings.ToLower(client))
return out, nil
}
if usage.IsAgent(client) || client == "other" || usage.AgentOf(client) == "magpie" || strings.HasPrefix(strings.ToLower(client), "magpie") {
return nil, fmt.Errorf("%s is counted on its own", client)
}
if !usage.IsAgent(as) || as == "magpie" {
return nil, fmt.Errorf("%s is not an agent magpie knows", as)
}
out[strings.ToLower(client)] = as
return out, nil
}
// bunSaid is what the page says for a bun that can't start, by why: an
// i18n.js key the page's api() puts through t(), kept here so app.js
// carries one line for it, not both sentences
var bunSaid = map[string]string{
"windows": "Bun, which runs plugins, can't start on this version of Windows: it needs Windows 10 version 1809 or later, or Windows Server 2019 or later. Update Windows to use plugins, or set MAGPIE_BUN to a bun that runs here.",
"cpu": "Bun, which runs plugins, can't start on this computer's processor: it needs an x64 processor with SSE4.2 (Intel or AMD from 2008 on; in a virtual machine, a CPU type that passes it through). Run magpie on such a processor to use plugins, or set MAGPIE_BUN to a bun that runs here.",
}
// linkSaid is what the page says for an app's import link that nothing
// here opens, by whether it names a program that is gone: an i18n.js key
// like bunSaid's, with {app} and {exe} filled from the reply
var linkSaid = map[bool]string{
false: "Nothing on this computer opens {app}'s links, so {app} didn't open: open {app} once or install it again, then click Add magpie again",
true: "Nothing on this computer opens {app}'s links, so {app} didn't open: open {app} once or install it again, then click Add magpie again ({exe})",
}
// appOutJSON is Codex on magpie while its ChatGPT account is used up: the
// account, when it has room again (zero when the reading doesn't say), and
// whether a Codex app is left on the account, its app-server not
// restarted (provider.CodexAppStuck), for the user to reopen it.
type appOutJSON struct {
User string `json:"user,omitempty"`
Until *time.Time `json:"until,omitempty"`
Stuck bool `json:"stuck,omitempty"`
}
func codexAppOut() *appOutJSON {
o := &appOutJSON{Stuck: provider.CodexAppStuck()}
for _, l := range provider.Logins("codex") {
if l.Active {
o.User = l.User
}
}
if u := provider.CodexOutUntil(); !u.IsZero() {
o.Until = &u
}
return o
}