Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
package provider
// Retiring a built-in subscription. Each subscription with a mover below
// has a community plugin that does what the built-in does
// (github.com/magpie-community/plugins). Moving one puts its accounts onto
// the plugin under the same id, so agents on zed/<model>, the model picks,
// routing and fallbacks carry on as they were:
//
// 1. the plugin is installed, if it isn't;
// 2. each account's sign-in is kept as the plugin keeps one, in the order
// and on or off as the user had it;
// 3. each is tried as a request would try it (the plugin's loader and its
// model list for that account): one the vendor refuses is marked, and
// one that fails otherwise goes along untried, since the built-in is
// retired and the plugin is where the account is fixed now;
// 4. the id changes hands: the built-in's saved accounts go out of
// logins.json into migrations.json.
//
// A failure on the way (the install, the plugin not serving the id, a
// sign-in it won't import) puts the built-in's saved accounts back as they
// were — the plugin's newer tokens included, since a refresh token used
// once is spent — for the next try. The built-in serves nothing either
// way (Retired): MoveCandidates lists the accounts still to move, and why.
import (
"context"
"crypto/sha256"
"encoding/hex"
"encoding/json"
"errors"
"fmt"
"io/fs"
"log"
"maps"
"net/http"
"os"
"path/filepath"
"regexp"
"slices"
"sort"
"strconv"
"strings"
"sync"
"time"
"github.com/yetone/magpie/internal/filememo"
"github.com/yetone/magpie/internal/lastgood"
"github.com/yetone/magpie/internal/plugin"
"github.com/yetone/magpie/internal/settings"
"github.com/yetone/magpie/internal/update"
)
// A migration's states.
const (
MoveMoving = "moving" // under way, or cut short (put back at the next try)
MovePlugin = "plugin" // the plugin has the id
MovedBack = "back" // moved back to the built-in by an older magpie: moved again by itself
MoveFailed = "failed" // the last try failed: the built-in carries on
// MoveRemoved is a moved one whose plugin the user removed: its
// accounts stay with the plugin's sign-ins, and the plugin installed
// again has it at once (HandOver). Nothing installs it by itself.
MoveRemoved = "removed"
)
// retiring are the built-ins magpie moves onto their plugins by itself:
// every one with a mover, since each built-in is being retired (the owner,
// 10-16: 陆续把内置Provider下线掉). A tests' list stands in for it.
var retiring = MovableIDs
// moveRetry is how long a failed move waits before it is tried again,
// while the built-in carries on. One whose built-in is retired waits
// retiredRetry: nothing serves its accounts until it moves, so a move that
// failed for a moment (npm out of reach, the plugin not installed yet) is
// tried again soon, not hours later.
const (
moveRetry = 6 * time.Hour
retiredRetry = 10 * time.Minute
)
// retryWait is how long a failed move of id waits before it is tried again.
func retryWait(id string) time.Duration {
if BuiltinRetired(id) {
return retiredRetry
}
return moveRetry
}
// retryDue says whether a failed move of id, last tried at, is due again.
func retryDue(id string, at time.Time) bool { return time.Since(at) >= retryWait(id) }
// Migration is where one built-in's move stands.
type Migration struct {
State string `json:"state"`
Package string `json:"package,omitempty"`
At time.Time `json:"at"`
Err string `json:"error,omitempty"`
// Accounts are the plugin's accounts the move made or took over.
Accounts []movedAccount `json:"accounts,omitempty"`
// Backup is the built-in's accounts as logins.json kept them.
Backup []savedLogin `json:"backup,omitempty"`
// Kept is what else of the built-in's the move set aside (Kiro's key).
Kept json.RawMessage `json:"kept,omitempty"`
// Installed is whether the move installed the plugin: a failed move
// takes it away again.
Installed bool `json:"installed,omitempty"`
// Host is the built-in's API host, which the plugin's provider shows.
Host string `json:"host,omitempty"`
// Why is a failed move's reason, for the page to say in the user's
// language.
Why *MoveWhy `json:"why,omitempty"`
}
// MoveWhy is why a move didn't go through: Code names the case, Args fill
// in its sentence.
//
// offline magpie couldn't reach npm (or Bun's download) to install the plugin
// install npm couldn't install it: line
//
// An older magpie also failed a move for an account (lapsed, unserved,
// account), which the page still reads from migrations.json; since the
// built-ins are retired every account goes along.
type MoveWhy struct {
Code string `json:"code"`
Args map[string]string `json:"args,omitempty"`
}
// moveError is a failed move's error in words a user reads, with its why.
type moveError struct {
why MoveWhy
msg string
err error // what lay under it, for the log
}
func (e *moveError) Error() string { return e.msg }
func (e *moveError) Unwrap() error { return e.err }
// WhyOf is the reason a move failed, nil for one it has no words for.
func WhyOf(err error) *MoveWhy {
var me *moveError
if errors.As(err, &me) {
w := me.why
return &w
}
return nil
}
// unreachable is an install that never got through to npm (or to Bun's
// download): Bun's words for it, and Go's.
var unreachable = regexp.MustCompile(`(?i)ConnectionRefused|ConnectionClosed|FailedToOpenSocket|ENOTFOUND|ETIMEDOUT|ECONNRESET|ECONNREFUSED|EAI_AGAIN|Unable to connect|network|no such host|dial tcp|i/o timeout|TLS handshake`)
// installFailed says why the plugin couldn't be installed.
func installFailed(pkg string, err error) error {
if unreachable.MatchString(err.Error()) {
return &moveError{MoveWhy{Code: "offline"}, "magpie couldn't reach npm to install the plugin. Check the network or proxy, then try again.", err}
}
line := strings.TrimSpace(err.Error())
if ls := strings.Split(line, "\n"); len(ls) > 1 {
line = strings.TrimSpace(ls[len(ls)-1])
}
return &moveError{MoveWhy{Code: "install", Args: map[string]string{"line": line}}, fmt.Sprintf("npm couldn't install %s: %s", pkg, line), err}
}
// nameOf is the built-in id's name, as the providers list shows it.
func nameOf(id string) string {
// a retired built-in is listed no more: the name it had
if c, ok := movedCards[id]; ok {
return c.name
}
if id == QoderCNID {
return "Qoder CN"
}
for _, p := range All() {
if p.ID == id && !p.IsPlugin() && p.Name != "" {
return p.Name
}
}
return id
}
type movedAccount struct {
Key string `json:"key"`
User string `json:"user"`
Own bool `json:"own,omitempty"`
// ID is the vendor's id of the account (WorkBuddy's uid), where the
// mover reads one: two accounts of one name are told apart by it.
ID string `json:"id,omitempty"`
// Was is what the plugin kept at Key before, when the user had signed
// in to the same account through the plugin already.
Was map[string]any `json:"was,omitempty"`
// Sent is (a hash of) the sign-in given to the plugin: a plugin still
// holding it renewed nothing, so the built-in's own is as new.
Sent string `json:"sent,omitempty"`
}
// signinHash tells two sign-ins apart without keeping either.
func signinHash(a map[string]any) string {
h := sha256.Sum256([]byte(jsonText(a)))
return hex.EncodeToString(h[:8])
}
// renewedSince are the built-in's accounts whose sign-in isn't the one
// sent: the built-in renewed them while the move went on (a request, a
// refresh) and, a refresh token being spent once used, the plugin's copy
// may be dead.
func renewedSince(mv *mover, moved []movedAccount) []movedAccount {
now, err := mv.out()
if err != nil {
return nil
}
var out []movedAccount
for _, ma := range moved {
if ma.Own {
continue
}
if slices.ContainsFunc(now, func(a Moving) bool { return !a.Own && a.same(ma) && signinHash(a.Auth) != ma.Sent }) {
out = append(out, ma)
}
}
return out
}
// same is whether a is the account moved as ma: by the vendor's id where
// both have one, a name being no one's own (wakkana on Discord), else by
// name.
func (a Moving) same(ma movedAccount) bool {
if a.ID != "" && ma.ID != "" {
return a.ID == ma.ID
}
return strings.EqualFold(a.User, ma.User)
}
// Moving is one of a built-in's accounts on its way to the plugin.
type Moving struct {
User string
// ID is the vendor's id of the account, where the built-in kept one
// (WorkBuddy's uid).
ID string
First, On bool
// Lapsed is an account the vendor already refused: it goes along, but
// isn't tried.
Lapsed bool
// Plan is the plan the account showed, kept beside it until the
// plugin tells it anew.
Plan string
// Own is the agent's own sign-in (its CLI's, its app's), which the
// plugin reads where the agent keeps it, as the built-in did.
Own bool
Auth map[string]any
}
// A mover carries one built-in's accounts to its plugin and back.
type mover struct {
pkg string
// min is the oldest version of pkg that runs the accounts as moved
min string
// agents are the logins.json agents its accounts are saved under.
agents []string
// out is the built-in's accounts as the plugin's sign-ins, the one in
// use first.
out func() ([]Moving, error)
// back puts one of the plugin's sign-ins back into the built-in's
// saved accounts: into the one it came from (user), else a new one.
// It gives the accounts and the one it wrote to.
back func(ls []savedLogin, user string, auth map[string]any) ([]savedLogin, string, error)
// take and give set aside what else of the built-in's the plugin now
// has, and put it back.
take func() (json.RawMessage, error)
give func(json.RawMessage) error
// settle finishes the sign-ins handed back once logins.json is let go:
// what else of the built-in's they carry (a key onto its provider),
// whose saving syncs the agents, which read the accounts.
settle func(auths map[string]map[string]any) error
}
// movers are the deprecated built-ins and their plugins, by id. Once one
// is moved, its plugin serves it and the built-in's code no longer does:
// each built-in's files say so (PLUGIN-SERVED, AGENTS.md), and
// TestMovedBuiltinsSayTheirPlugin fails for a mover added without that.
var movers = map[string]*mover{}
// errStays is a back's answer for a sign-in the built-in has nowhere to
// keep (one made in the plugin's own way): it stays with the plugin, which
// lists it under its own id once the built-in has the id again.
var errStays = errors.New("stays with the plugin")
// Movable is whether the built-in id has a plugin it can move to.
func Movable(id string) bool { return movers[id] != nil }
// BuiltinRetired is whether magpie's built-in id is retired: its plugin serves
// it, and the built-in serves nothing, moved or not. One whose accounts
// haven't moved yet (a failed install, an account the plugin turned away)
// is listed by MoveCandidates with why, until it moves. The built-ins are
// retired one by one, each with its code (the owner, 10-16: 陆续把内置
// Provider下线掉), so this is the set retired so far.
func BuiltinRetired(id string) bool { return Movable(id) && retiredBuiltins[id] }
// retiredBuiltins are the built-in subscriptions whose code is gone.
var retiredBuiltins = map[string]bool{
"zed": true,
"kiro": true,
"cursor": true,
"qoder": true,
QoderCNID: true,
"workbuddy": true,
WorkBuddyAIID: true,
MiMoID: true,
"zcode": true,
"factory": true,
"grok": true,
"devin": true,
CommandCodePlanID: true,
}
// PluginServes is whether the built-in id's subscription is its plugin's to
// serve, and magpie's built-in code serves none of it: moved onto its plugin,
// or retired.
func PluginServes(id string) bool { return Moved(id) || BuiltinRetired(id) }
// MovableIDs are the built-ins that have a plugin to move to, by id: the
// page marks them deprecated, moved or not.
func MovableIDs() []string {
out := make([]string, 0, len(movers))
for id := range movers {
out = append(out, id)
}
sort.Strings(out)
return out
}
// MoveCandidate is a built-in with accounts its plugin could run instead.
type MoveCandidate struct {
ID string `json:"id"`
Name string `json:"name"`
Package string `json:"package"`
Accounts int `json:"accounts"`
// Error and Why are the last try's failure, when one failed
Error string `json:"error,omitempty"`
Why *MoveWhy `json:"why,omitempty"`
}
// MoveCandidates are the built-ins not on their plugins that have accounts
// to move, by name. One whose plugin the user removed (MoveRemoved) is
// none: its accounts moved already and are kept with the plugin's sign-ins,
// and installing the plugin again gives it back (HandOver), as MoveRetiring
// and HandOver leave it too. A login row of the built-in's left behind kept
// it here, so the Providers page's line said its accounts "haven't moved
// yet" for good, with a Move that would install the plugin the user had
// just removed (plugins#404: Grok, after the plugin, the provider and its
// sign-ins were removed; #3542: ZCode).
func MoveCandidates() []MoveCandidate {
if settings.AccountDiscoveryOff() {
return nil
}
out := []MoveCandidate{}
for id, mv := range movers {
if Moved(id) {
continue
}
if m, ok := MigrationOf(id); ok && m.State == MoveRemoved {
continue
}
if accts, err := mv.out(); err == nil && len(accts) > 0 {
c := MoveCandidate{ID: id, Name: nameOf(id), Package: mv.pkg, Accounts: len(accts)}
if m, ok := MigrationOf(id); ok && m.State == MoveFailed {
c.Error, c.Why = m.Err, m.Why
}
out = append(out, c)
}
}
sort.Slice(out, func(i, j int) bool { return out[i].Name < out[j].Name })
return out
}
// a retired subscription's id names its plugin to `magpie plugin add`
// and the Plugins page's field (qoder-cn, commandcode-plan)
func init() { plugin.SubscriptionPlugin = MovePackage }
// MovePackage is the plugin the built-in id moves to.
func MovePackage(id string) string {
if m := movers[id]; m != nil {
return m.pkg
}
return ""
}
func migrationsPath() string { return filepath.Join(filepath.Dir(Path()), "migrations.json") }
var migrationsMu sync.Mutex
// readMigrations is held while a request reads: the GUI's state asks each
// provider's move several times over, thousands of looks at the file.
func readMigrations() map[string]Migration { return heldOf("migrations", readMigrationsFile) }
func readMigrationsFile() map[string]Migration {
m, err := filememo.Read("migrations", migrationsPath(), parseMigrations)
if err != nil && !errors.Is(err, fs.ErrNotExist) {
// one that doesn't read (all zero after a crash, #1505) is not
// "nothing moved": a moved subscription would come back as its
// built-in, and the next move write that over every other's
if b, ferr := lastgood.Fallback(migrationsPath(), unreadBytes(migrationsPath()), validMigrations); ferr == nil {
m, _ = parseMigrations(b)
} else {
log.Printf("migrations.json: %v", ferr)
}
}
return m
}
func parseMigrations(b []byte) (map[string]Migration, error) {
var m map[string]Migration
err := json.Unmarshal(b, &m)
return m, err
}
func validMigrations(b []byte) bool {
_, err := parseMigrations(b)
return err == nil
}
// MigrationOf is where the built-in id's move stands.
func MigrationOf(id string) (Migration, bool) {
m, ok := readMigrations()[id]
return m, ok
}
// Moved is whether the built-in id's accounts are its plugin's now.
func Moved(id string) bool {
m, ok := MigrationOf(id)
return ok && m.State == MovePlugin
}
// movedAgent is whether the logins.json agent's accounts are a moved
// built-in's, its plugin's now. Retired is not enough: a retired
// built-in's own account, the agent's own sign-in, still has to be listed
// for its mover to take it (MoveRetiring, MoveCandidates).
func movedAgent(agent string) bool {
for id, mv := range movers {
if slices.Contains(mv.agents, agent) && Moved(id) {
return true
}
}
return false
}
// OnPlugins are the built-ins moved onto their plugins.
func OnPlugins() []string {
var out []string
for id, m := range readMigrations() {
if m.State == MovePlugin && movers[id] != nil {
out = append(out, id)
}
}
sort.Strings(out)
return out
}
func movingNow(id string) bool {
m, ok := MigrationOf(id)
return ok && m.State == MoveMoving
}
func setMigration(id string, f func(m *Migration)) error {
migrationsMu.Lock()
defer migrationsMu.Unlock()
all := map[string]Migration{}
for k, v := range readMigrationsFile() {
all[k] = v
}
// f changes its own copy: the lists read are shared with every reader
// (filememo), and a write that fails leaves them as the file has them
m := all[id]
m.Accounts = slices.Clone(m.Accounts)
for i := range m.Accounts {
m.Accounts[i].Was = maps.Clone(m.Accounts[i].Was)
}
m.Backup = slices.Clone(m.Backup)
f(&m)
all[id] = m
b, err := json.MarshalIndent(all, "", " ")
if err != nil {
return err
}
defer Changed()
if err := lastgood.Keep(migrationsPath(), validMigrations, 0o600); err != nil {
return err
}
return writePrivate(migrationsPath(), append(b, '\n'))
}
// lockMoves keeps two magpies (the app and a CLI, a dev build beside a
// release) from moving at once.
func lockMoves() (func(), error) {
p := migrationsPath() + ".lock"
if err := os.MkdirAll(filepath.Dir(p), 0o700); err != nil {
return nil, err
}
for range 2 {
f, err := os.OpenFile(p, os.O_CREATE|os.O_EXCL|os.O_WRONLY, 0o600)
if err == nil {
fmt.Fprint(f, os.Getpid())
f.Close()
return func() { os.Remove(p) }, nil
}
// one left by a magpie that died moving (killed, or stopped
// mid-move) holds nothing
if b, rerr := os.ReadFile(p); rerr == nil {
if pid, perr := strconv.Atoi(strings.TrimSpace(string(b))); perr == nil && pid != os.Getpid() && !update.Alive(pid) {
os.Remove(p)
continue
}
}
if fi, serr := os.Stat(p); serr == nil && time.Since(fi.ModTime()) > 15*time.Minute {
os.Remove(p)
continue
}
return nil, errors.New("another magpie is moving subscriptions to plugins")
}
return nil, errors.New("another magpie is moving subscriptions to plugins")
}
// Hooks the tests stand in for.
var (
installPlugin = func(ctx context.Context, pkg, min string) error {
// what the user has is theirs: a version they pinned stays, and
// a git one is reinstalled from its own repository, where a bare
// name would replace either with <pkg>@latest
found, older := pkg, false
for _, e := range plugin.Load().Plugins {
if plugin.PackageName(e.Spec) != pkg {
continue
}
if e.Off {
return fmt.Errorf("%s is turned off in Plugins", pkg)
}
v := plugin.Version(e.Spec)
if min == "" || !update.Newer(min, v) {
return nil
}
if plugin.IsPath(e.Spec) {
return fmt.Errorf("%s at %s is %s; moving needs %s or newer", pkg, e.Spec, v, min)
}
if plugin.Pinned(e.Spec) {
return fmt.Errorf("%s is pinned at %s; moving needs %s or newer", pkg, e.Spec, min)
}
found, older = e.Spec, !plugin.IsGit(e.Spec)
break
}
var err error
if older {
// npm's newest, which bun says why it won't install (a
// minimumReleaseAge), where bun's own latest is an older
// version without a word (sweanng424 on Discord)
err = upgradePlugin(ctx, pkg)
} else {
_, err = addPlugin(ctx, found)
}
if err == nil && min != "" {
if v := plugin.Version(pkg); update.Newer(min, v) {
return fmt.Errorf("%s %s is installed; moving needs %s or newer", pkg, v, min)
}
}
return err
}
pluginProviders = plugin.Providers
removePlugin = plugin.Remove
// addPlugin and upgradePlugin install what installPlugin decided: vars
// so a test can read what it is handed
addPlugin = plugin.Add
upgradePlugin = plugin.Upgrade
// addPluginExact is a backup's or a sync's install: the spec as the
// other computer has it, never taken for a name
addPluginExact = plugin.AddExact
// importAuth keeps a built-in's sign-in as one of the plugin's
importAuth = plugin.Import
)
// Move puts the built-in id's accounts onto its plugin (see above). An
// error leaves the built-in as it was.
func Move(ctx context.Context, id string) error {
if settings.AccountDiscoveryOff() {
return errAccountDiscoveryOff
}
mv := movers[id]
if mv == nil {
return fmt.Errorf("%s has no plugin to move to", id)
}
unlock, err := lockMoves()
if err != nil {
return err
}
defer unlock()
if Moved(id) {
return nil
}
if movingNow(id) {
putBack(ctx, id, mv, "")
}
err = move(ctx, id, mv)
if err != nil {
_ = setMigration(id, func(m *Migration) {
*m = Migration{State: MoveFailed, Package: mv.pkg, At: time.Now().UTC().Truncate(time.Second), Err: err.Error(), Why: WhyOf(err)}
})
if me := (*moveError)(nil); errors.As(err, &me) && me.err != nil {
log.Printf("moving %s to its plugin: %s (%s)", id, me.msg, me.err)
}
}
return err
}
// Adopt puts the built-in id onto its plugin before any account of it is
// signed in: the plugin installed, and the subscription signs in through
// it from now on, as a moved one does. One with accounts is moved instead,
// and one whose plugin the user removed is the plugin's again.
func Adopt(ctx context.Context, id string) error {
if settings.AccountDiscoveryOff() {
return errAccountDiscoveryOff
}
mv := movers[id]
if mv == nil {
return fmt.Errorf("%s has no plugin to move to", id)
}
if accts, err := mv.out(); err != nil {
return err
} else if len(accts) > 0 {
return Move(ctx, id)
}
unlock, err := lockMoves()
if err != nil {
return err
}
defer unlock()
if Moved(id) {
return nil
}
had := pluginListed(mv.pkg)
if err := installPlugin(ctx, mv.pkg, mv.min); err != nil {
return installFailed(mv.pkg, err)
}
pps, err := pluginProviders(ctx)
if err == nil && !slices.ContainsFunc(pps, func(p plugin.Provider) bool { return p.ID == id && plugin.PackageName(p.Spec) == mv.pkg }) {
err = fmt.Errorf("%s doesn't serve %s", mv.pkg, id)
}
if err == nil {
err = setMigration(id, func(m *Migration) {
at := time.Now().UTC().Truncate(time.Second)
// one whose plugin the user removed: its accounts are with
// the plugin's sign-ins still, and the record says which
if m.State == MoveRemoved {
m.State, m.At, m.Installed = MovePlugin, at, !had
return
}
*m = Migration{State: MovePlugin, Package: mv.pkg, At: at, Installed: !had}
})
}
if err != nil && !had {
if rerr := removePlugin(context.WithoutCancel(ctx), mv.pkg); rerr != nil {
log.Printf("removing %s after %s failed to go onto it: %s", mv.pkg, id, rerr)
}
}
return err
}
func move(ctx context.Context, id string, mv *mover) (err error) {
var host string
if p, err := Find(id); err == nil && !p.IsPlugin() {
host = p.Host()
}
accts, err := mv.out()
if err != nil {
return err
}
if len(accts) == 0 {
return fmt.Errorf("no %s account to move", id)
}
had := pluginListed(mv.pkg)
if err := installPlugin(ctx, mv.pkg, mv.min); err != nil {
return installFailed(mv.pkg, err)
}
installed := !had
// a plugin the move installed goes with a move that failed, which
// leaves nothing of it behind: no provider saying it's signed out
defer func() {
if err != nil && installed {
if rerr := removePlugin(context.WithoutCancel(ctx), mv.pkg); rerr != nil {
log.Printf("removing %s after a failed move: %s", mv.pkg, rerr)
}
}
}()
pps, err := pluginProviders(ctx)
if err != nil {
return err
}
var pp plugin.Provider
for _, p := range pps {
if p.ID == id {
if plugin.PackageName(p.Spec) != mv.pkg {
return fmt.Errorf("%s is served by another plugin, %s", id, p.Spec)
}
pp = p
}
}
if pp.ID == "" {
return fmt.Errorf("%s doesn't serve %s", mv.pkg, id)
}
before := plugin.Auths(id)
if err := setMigration(id, func(m *Migration) {
*m = Migration{State: MoveMoving, Package: mv.pkg, At: time.Now().UTC().Truncate(time.Second)}
}); err != nil {
return err
}
defer func() {
if err != nil {
putBack(ctx, id, mv, err.Error())
}
}()
var moved []movedAccount
for _, a := range accts {
key, err := importAuth(ctx, id, a.Auth)
if err != nil {
return fmt.Errorf("%s: %w", a.User, err)
}
ma := movedAccount{Key: key, User: a.User, Own: a.Own, ID: a.ID, Was: before[key], Sent: signinHash(a.Auth)}
moved = append(moved, ma)
if err := setMigration(id, func(m *Migration) { m.Accounts = moved }); err != nil {
return err
}
}
if err := keepOrder(pp, accts, moved); err != nil {
return err
}
// the built-in is retired, so every account goes: one the vendor
// refuses is marked, as the built-in marked it; one that is lapsed,
// or that the plugin couldn't prove (its vendor unreachable, its sign-in
// gone in words), goes untried and unmarked, and the plugin's own reads
// judge it from now on. No model the built-in served holds it back.
for i, a := range accts {
if a.Lapsed {
continue
}
// through the account's proxy, as its requests go
c, err := plugin.Check(ViaLogin(ctx, id, a.User), id, moved[i].Key)
switch {
case err == nil && (c.Refused != "" || refused(c.Usage)):
notePluginLapse(pp, moved[i].Key, http.StatusUnauthorized)
case err != nil:
log.Printf("moving %s's %s to its plugin untried: %s", id, a.User, err)
}
}
return commitMove(id, mv, moved, installed, host)
}
// refused is a check's usage read saying the vendor turned the account's
// sign-in away, read as the usage page reads it: a models hook may fall
// back to a list it keeps, but the read asks the vendor of the account.
func refused(u *plugin.Usage) bool {
return u != nil && (u.SignIn == "expired" || u.SignIn == "" && signInGone.MatchString(u.Error))
}
// pluginListed is whether the package is in the plugin list already.
func pluginListed(pkg string) bool {
return slices.ContainsFunc(plugin.Load().Plugins, func(e plugin.Entry) bool { return plugin.PackageName(e.Spec) == pkg })
}
// keepOrder lists the accounts moved as the built-in had them: the one in
// use first, the rest on or off. What the user had signed in to through
// the plugin already keeps its place.
func keepOrder(pp plugin.Provider, accts []Moving, moved []movedAccount) error {
agent := pluginAgent(pp)
loginsMu.Lock()
defer loginsMu.Unlock()
ls := readLogins()
first := ""
for i, a := range accts {
if a.First && moved[i].Was == nil {
first = moved[i].Key
}
}
for i, a := range accts {
ma := moved[i]
if ma.Was != nil {
continue
}
ls = slices.DeleteFunc(ls, func(l savedLogin) bool { return l.Agent == agent && l.Home == ma.Key })
l := savedLogin{Agent: agent, User: a.User, Plan: a.Plan, Home: ma.Key, On: a.On || a.First, First: ma.Key == first, Seen: time.Now().UTC().Truncate(time.Second)}
if a.Lapsed {
l.Lapsed = lapsedText(pp, a.User)
}
ls = append(ls, l)
}
if first != "" {
for i := range ls {
if ls[i].Agent == agent && ls[i].Home != first {
ls[i].First = false
}
}
}
return writeLogins(ls)
}
// commitMove hands the id over: the built-in's accounts go aside.
func commitMove(id string, mv *mover, moved []movedAccount, installed bool, host string) error {
if r := renewedSince(mv, moved); len(r) > 0 {
var users []string
for _, ma := range r {
users = append(users, ma.User)
}
return fmt.Errorf("%s renewed while moving; tried again later", strings.Join(users, ", "))
}
var kept json.RawMessage
if mv.take != nil {
k, err := mv.take()
if err != nil {
return err
}
kept = k
}
loginsMu.Lock()
var backup []savedLogin
for _, l := range readLogins() {
if slices.Contains(mv.agents, l.Agent) {
backup = append(backup, l)
}
}
loginsMu.Unlock()
if err := setMigration(id, func(m *Migration) {
*m = Migration{State: MovePlugin, Package: mv.pkg, At: time.Now().UTC().Truncate(time.Second), Accounts: moved, Backup: backup, Kept: kept, Installed: installed, Host: host}
}); err != nil {
if mv.give != nil {
_ = mv.give(kept)
}
return err
}
tidyMoved(id)
return nil
}
// tidyMoved takes a moved built-in's accounts out of logins.json (into its
// backup, if one was left behind when a magpie stopped between the two).
func tidyMoved(id string) {
mv := movers[id]
if mv == nil || !Moved(id) {
return
}
loginsMu.Lock()
ls := readLogins()
var left []savedLogin
ls = slices.DeleteFunc(ls, func(l savedLogin) bool {
if slices.Contains(mv.agents, l.Agent) {
left = append(left, l)
return true
}
return false
})
if len(left) > 0 {
_ = writeLogins(ls)
}
loginsMu.Unlock()
if len(left) == 0 {
return
}
_ = setMigration(id, func(m *Migration) {
for _, l := range left {
if !slices.ContainsFunc(m.Backup, func(b savedLogin) bool { return sameMoved(b, l) }) {
m.Backup = append(m.Backup, l)
}
}
})
}
func sameMoved(a, b savedLogin) bool {
return a.Agent == b.Agent && strings.EqualFold(a.User, b.User) && a.Home == b.Home
}
// putBack undoes a move cut short: the plugin's sign-ins go back into the
// built-in's accounts (its newer tokens with them), then out of the
// plugin — but for one the user had there already, which gets back what
// it had.
func putBack(ctx context.Context, id string, mv *mover, why string) {
m, _ := MigrationOf(id)
var keys []string
for _, ma := range m.Accounts {
keys = append(keys, ma.Key)
}
renewed := renewedSince(mv, m.Accounts)
skip := func(ma movedAccount, a map[string]any) bool {
return signinHash(a) == ma.Sent || slices.ContainsFunc(renewed, func(r movedAccount) bool { return r.Key == ma.Key })
}
_, _, _ = handBack(ctx, id, mv, m.Accounts, keys, skip, nil, func(ls []savedLogin, _ map[string]string) []savedLogin { return ls })
for _, ma := range m.Accounts {
if ma.Was != nil {
_ = plugin.Restore(ctx, id, ma.Key, ma.Was)
}
}
// the plugin's rows keepOrder wrote go with its accounts, but for one
// the user had there before
loginsMu.Lock()
ls := readLogins()
if n := len(ls); n > 0 {
ls = slices.DeleteFunc(ls, func(l savedLogin) bool {
return l.Agent == "plugin:"+id && slices.ContainsFunc(m.Accounts, func(ma movedAccount) bool { return ma.Key == l.Home && ma.Was == nil })
})
if len(ls) != n {
_ = writeLogins(ls)
}
}
loginsMu.Unlock()
_ = setMigration(id, func(m *Migration) {
*m = Migration{State: MoveFailed, Package: mv.pkg, At: time.Now().UTC().Truncate(time.Second), Err: why}
})
}
// handBack writes the plugin's accounts keys back into the built-in's
// saved accounts, then takes them out of the plugin. They are written
// before they are taken, so a magpie stopped between the two loses no
// sign-in; one the plugin renewed in between is written again. arrange
// finishes the accounts written (given each key's user). An account that
// can't go back stops it all before anything is written.
func handBack(ctx context.Context, id string, mv *mover, accts []movedAccount, keys []string, skip func(movedAccount, map[string]any) bool, prep, arrange func([]savedLogin, map[string]string) []savedLogin) (map[string]string, []error, error) {
var stays []string
byKey := map[string]movedAccount{}
for _, ma := range accts {
byKey[ma.Key] = ma
}
write := func(auths map[string]map[string]any) (map[string]string, []error, error) {
loginsMu.Lock()
defer loginsMu.Unlock()
ls := readLogins()
if prep != nil {
ls = prep(ls, nil)
}
users := map[string]string{}
var errs []error
stays = nil
for _, k := range keys {
ma := byKey[k]
if ma.Own {
users[k] = ma.User
continue
}
a := auths[k]
if a == nil {
continue
}
if skip != nil && skip(ma, a) {
users[k] = ma.User
continue
}
next, u, err := mv.back(ls, ma.User, a)
if errors.Is(err, errStays) {
stays = append(stays, k)
continue
}
if err != nil {
errs = append(errs, err)
continue
}
ls, users[k] = next, u
}
if len(errs) > 0 {
return users, errs, nil
}
return users, nil, writeLogins(arrange(ls, users))
}
settle := func(auths map[string]map[string]any) error {
if mv.settle == nil {
return nil
}
mine := map[string]map[string]any{}
for _, k := range keys {
if a := auths[k]; a != nil && !byKey[k].Own {
mine[k] = a
}
}
return mv.settle(mine)
}
seen := plugin.Auths(id)
users, errs, err := write(seen)
if err == nil && len(errs) == 0 {
err = settle(seen)
}
if err != nil || len(errs) > 0 {
return users, errs, err
}
keys = slices.DeleteFunc(slices.Clone(keys), func(k string) bool { return slices.Contains(stays, k) })
if len(keys) == 0 {
return users, nil, nil
}
taken, err := plugin.Take(ctx, id, keys)
if err != nil {
return users, nil, err
}
for _, k := range keys {
if t := taken[k]; t != nil && jsonText(t) != jsonText(seen[k]) {
users, errs, err := write(taken)
if err == nil && len(errs) == 0 {
err = settle(taken)
}
return users, errs, err
}
}
return users, nil, nil
}
// MoveRetiring moves the built-ins being retired that have accounts, at
// start-up: once, or again retryWait after one failed. One an older magpie
// moved back is moved again: there is no way back, as the built-in is
// going. One whose plugin the user removed waits for them to install it.
func MoveRetiring(ctx context.Context) map[string]error {
if settings.AccountDiscoveryOff() {
return nil
}
out := map[string]error{}
for _, id := range retiring() {
m, ok := MigrationOf(id)
switch {
case ok && m.State == MovePlugin:
tidyMoved(id)
continue
case ok && m.State == MoveRemoved:
continue
case ok && m.State == MoveFailed && !retryDue(id, m.At):
continue
}
if accts, err := movers[id].out(); err != nil || len(accts) == 0 {
continue
}
out[id] = Move(ctx, id)
}
return out
}
// HandOver gives each deprecated built-in whose plugin the user has
// installed, at the version its move needs, and which that plugin serves,
// its id, so one subscription is never listed twice: the built-in, and the
// plugin's under "<id>-plugin" (ARNO on Discord: Qoder CN twice once the
// Qoder plugin's 0.2.0 served it, as nothing gave it the id). One with no
// accounts is the plugin's at once, as Adopt makes it; with accounts too,
// one that has some is moved (Move: each tried through the plugin, all put
// back on any failure, the built-in carrying on). One the plugin has
// accounts of its own for already is left as it is, since its models are
// in use as <id>-plugin's and the id changing would leave agents asking
// for a provider gone; the add sheet lists it once regardless. One moved
// whose plugin the user removed is the plugin's again once they install it,
// its accounts still with the plugin, and a failed move waits retryWait. No
// plugin is installed for it: the user's own install is what says to.
func HandOver(ctx context.Context, accounts bool) map[string]error {
if settings.AccountDiscoveryOff() {
return nil
}
out := map[string]error{}
var pps []plugin.Provider
asked := false
for _, id := range MovableIDs() {
mv := movers[id]
m, ok := MigrationOf(id)
if ok && m.State == MoveRemoved {
if pluginReady(mv) {
out[id] = setMigration(id, func(m *Migration) {
m.State, m.At, m.Installed = MovePlugin, time.Now().UTC().Truncate(time.Second), false
})
}
continue
}
if ok && (m.State != MoveFailed || !retryDue(id, m.At)) {
continue
}
if !pluginReady(mv) {
continue
}
if !asked {
var err error
if pps, err = pluginProviders(ctx); err != nil {
return out
}
asked = true
}
i := slices.IndexFunc(pps, func(p plugin.Provider) bool { return p.ID == id && plugin.PackageName(p.Spec) == mv.pkg })
if i < 0 || pps[i].SignedIn || len(pps[i].Accounts) > 0 {
continue
}
accts, err := mv.out()
switch {
case err != nil:
case len(accts) == 0:
out[id] = Adopt(ctx, id)
case accounts:
out[id] = Move(ctx, id)
}
}
return out
}
// pluginReady is whether the mover's plugin is installed, switched on and
// at the version its move needs.
func pluginReady(mv *mover) bool {
for _, e := range plugin.Load().Plugins {
if plugin.PackageName(e.Spec) == mv.pkg {
return !e.Off && (mv.min == "" || !update.Newer(mv.min, plugin.Version(e.Spec)))
}
}
return false
}
// keepMovedCurrent updates the plugin of each built-in moved onto one to
// the version its move needs, when older: a built-in came up to date with
// magpie, and its plugin does too. One turned off or run from a folder is
// left as it is.
func keepMovedCurrent(ctx context.Context) {
for _, id := range OnPlugins() {
mv := movers[id]
if mv.min == "" {
continue
}
if err := installPlugin(ctx, mv.pkg, mv.min); err != nil {
log.Printf("updating %s's plugin: %s", id, err)
}
}
}
// KeepRetiringMoved moves the built-ins being retired, and hands over
// those whose plugin the user installed (HandOver), run by the magpie
// serving the gateway (one magpie, never two at once): a little after it
// starts, then every hour, so a failed move is tried again once retryWait
// has gone; a retired built-in's failed move brings the next run forward
// to when it is due. It also keeps each moved built-in's plugin up to date.
func KeepRetiringMoved(ctx context.Context) {
t := time.NewTimer(20 * time.Second)
defer t.Stop()
for {
select {
case <-ctx.Done():
return
case <-t.C:
}
if settings.AccountDiscoveryOff() {
t.Reset(time.Hour)
continue
}
keepMovedCurrent(ctx)
moves := MoveRetiring(ctx)
maps.Copy(moves, HandOver(ctx, true))
for id, err := range moves {
if err != nil {
log.Printf("moving %s to its plugin: %s (nothing serves it until it moves)", id, err)
} else {
log.Printf("moved %s to its plugin, %s", id, MovePackage(id))
}
}
t.Reset(nextRetiringRun())
}
}
// nextRetiringRun is how long KeepRetiringMoved waits before it runs
// again: an hour, or less when a retired built-in's failed move is due
// sooner.
func nextRetiringRun() time.Duration {
next := time.Hour
for _, id := range MovableIDs() {
if m, ok := MigrationOf(id); ok && m.State == MoveFailed && BuiltinRetired(id) {
next = min(next, max(time.Until(m.At.Add(retiredRetry)), time.Minute))
}
}
return next
}
// MovedOnto are the built-ins moved onto the plugin named (its spec or
// package name).
func MovedOnto(name string) []string {
var out []string
for _, e := range plugin.Load().Plugins {
if plugin.Name(e.Spec) != name && e.Spec != name {
continue
}
pkg := plugin.PackageName(e.Spec)
for _, id := range OnPlugins() {
if m, _ := MigrationOf(id); m.Package == pkg && !slices.Contains(out, id) {
out = append(out, id)
}
}
}
return out
}
// PluginAgentGoing, set by internal/agent, takes magpie out of the config
// of the agent the plugin spec adds and puts back what the user had, as
// `magpie <agent> default` does. It runs before the plugin is turned off
// or removed, while magpie still knows the agent: after, nothing could
// (#3810).
var PluginAgentGoing func(spec string) error
// agentGoing runs PluginAgentGoing for the installed plugin named; an
// error keeps the plugin as it is.
func agentGoing(name, left string) error {
spec := installedSpec(name)
if spec == "" || PluginAgentGoing == nil {
return nil
}
if err := PluginAgentGoing(spec); err != nil {
return fmt.Errorf("%s is left %s: magpie couldn't put back its agent's config as it was (%w); switch the agent off magpie first", name, left, err)
}
return nil
}
// RemovePlugin removes the plugin named and sets aside the model picks of
// its providers it leaves in providers.json (plugin_left.go). A built-in
// moved onto it isn't moved back, as the built-in is going: it is
// MoveRemoved, its accounts kept with the plugin's sign-ins for when the
// plugin is installed again. The agent it adds is taken off magpie first
// (PluginAgentGoing).
func RemovePlugin(ctx context.Context, name string) error {
if err := agentGoing(name, "installed"); err != nil {
return err
}
// what it served is read while it is still on the list
moved := MovedOnto(name)
spec := installedSpec(name)
ids, known := pluginRecordIDs(spec)
pkg := plugin.PackageName(spec)
if err := plugin.Remove(ctx, name); err != nil {
return err
}
for _, id := range moved {
if err := setMigration(id, func(m *Migration) {
m.State, m.At = MoveRemoved, time.Now().UTC().Truncate(time.Second)
}); err != nil {
return fmt.Errorf("%s is removed; %s still reads as on it: %w", name, id, err)
}
}
if spec == "" || !known {
return nil
}
if err := setAside(pkg, ids); err != nil {
return fmt.Errorf("%s is removed; its model picks were left in providers.json: %w", name, err)
}
return nil
}
// SetPluginOff turns the plugin named off, or back on. A built-in moved
// onto it stays moved, off with it: nothing moves it back, as the built-in
// is going. The agent it adds is taken off magpie before it is off
// (PluginAgentGoing), and stays off when it is on again: the agent's
// switch puts back the model it was on.
func SetPluginOff(_ context.Context, name string, off bool) error {
if off {
if err := agentGoing(name, "on"); err != nil {
return err
}
}
return plugin.SetOff(name, off)
}