Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
package provider
import (
"context"
"errors"
"regexp"
"strings"
"time"
"github.com/yetone/magpie/internal/plugin"
"github.com/yetone/magpie/internal/settings"
)
// StartPluginSignIn begins signing in to a plugin's provider (OpenCode's
// id) with its OAuth method, the method's questions answered: the page to
// open, then either the plugin notices on its own or the code the page
// shows is pasted back (SubmitSignInCallback). SignInStatus follows it,
// as it does a built-in sign-in; its Agent is the provider's magpie id.
// The account goes beside those signed in already, or replaces the one it
// is. A built-in moved onto its plugin installs the CLI it runs through
// first, as the built-in's sign-in did.
func StartPluginSignIn(id string, method int, inputs map[string]string) (SignInState, error) {
return StartPluginSignInWith(id, method, inputs, SignInOptions{})
}
// StartPluginSignInWith is StartPluginSignIn through the proxy o picks,
// else the one the provider's requests go through (#1663).
func StartPluginSignInWith(id string, method int, inputs map[string]string, o SignInOptions) (SignInState, error) {
if settings.AccountDiscoveryOff() {
return SignInState{}, errAccountDiscoveryOff
}
s := &signInFlow{done: make(chan struct{})}
if err := s.pickProxy(PluginID(id), o); err != nil {
return SignInState{}, err
}
s.st = SignInState{ID: randomToken(9), Agent: PluginID(id), State: "waiting", Proxy: s.proxy}
cli, install := pluginCLI(id)
var installing context.Context
if install {
s.st.State, s.st.Installing = "installing", cli.Name
installing, s.stop = context.WithCancel(context.Background())
} else if err := s.pluginBegin(id, method, inputs); err != nil {
return SignInState{}, err
}
signIns.Lock()
for sid, o := range signIns.m {
if o.st.Agent == s.st.Agent {
o.finish(SignInState{State: "canceled"})
delete(signIns.m, sid)
}
}
signIns.m[s.st.ID] = s
signIns.Unlock()
if install {
go func() {
err := installCLI(installing, cli)
if err == nil {
forgetAccountCaches()
err = s.pluginBegin(id, method, inputs)
}
if err != nil {
s.finish(SignInState{State: "failed", Error: err.Error()})
}
}()
}
return s.status(), nil
}
// pluginRunsCLI are the plugins (by OpenCode's id) that sign in with the
// vendor's CLI themselves, as the built-in did: the community Grok plugin
// runs `grok login`. One installed beside the built-in, not moved onto,
// said "install Grok Build first: curl … | bash", which a magpie in Docker
// has no shell to run; its CLI is installed first, as a moved one's is.
var pluginRunsCLI = map[string]bool{"grok": true}
// pluginCLI is the vendor CLI a plugin's sign-in (OpenCode's id) runs
// through and this machine lacks: a moved built-in's, or one in
// pluginRunsCLI.
func pluginCLI(id string) (agentCLI, bool) {
if PluginServes(PluginID(id)) {
return missingCLI(PluginID(id))
}
if pluginRunsCLI[id] {
return missingCLI(id)
}
return agentCLI{}, false
}
// PluginCLIMissing is the name of the vendor CLI a plugin's sign-in runs
// through and this machine lacks (Grok Build for Grok's), "" when there is
// none to install. The command line's sign-in installs it first, as
// StartPluginSignIn does; without it, `magpie plugin login grok` in Docker
// said "install Grok Build first: curl … | bash", which the image has no
// curl to run (#2223).
func PluginCLIMissing(id string) string {
c, ok := pluginCLI(id)
if !ok {
return ""
}
return c.Name
}
// InstallPluginCLI installs the CLI PluginCLIMissing names, with its
// vendor's installer or, where that can't run, as it installs it.
func InstallPluginCLI(ctx context.Context, id string) error {
c, ok := pluginCLI(id)
if !ok {
return nil
}
if err := installCLI(ctx, c); err != nil {
return err
}
forgetAccountCaches()
return nil
}
// pluginBegin asks the plugin for the page to open and waits for the
// sign-in to finish there, or for the code the page shows.
func (s *signInFlow) pluginBegin(id string, method int, inputs map[string]string) error {
ctx, cancel := context.WithTimeout(s.via(context.Background()), time.Minute)
a, err := plugin.Authorize(ctx, id, method, inputs, plugin.NewAccount)
cancel()
if err != nil {
return err
}
wait, stop := context.WithTimeout(context.Background(), signInTimeout)
s.mu.Lock()
if s.st.State != "waiting" && s.st.State != "installing" {
// canceled while the CLI was installed
s.mu.Unlock()
stop()
return nil
}
s.st.State, s.st.Installing = "waiting", ""
s.st.URL, s.st.Instructions, s.st.Code, s.st.Opened = a.URL, a.Instructions, codeIn(a.Instructions), a.Opened
s.stop = stop
if a.Method == "code" {
s.st.PasteCode, s.plugin = true, a.Session
} else if PluginPastesCallback(id, a.URL) {
// a browser that can't reach the plugin's port here ends on a page
// that won't load: its address finishes it
s.st.PasteCallback, s.pluginPorts = true, loopbackPorts(a.URL)
} else if m, keys, ok := pluginKeyMethod(id); ok && m != method {
// its page posts where nothing can be pasted: a key made on the
// keys page finishes it
s.st.PasteKey, s.st.KeysURL, s.pluginKey = true, keys, &pluginKeyWay{id: id, method: m}
}
s.mu.Unlock()
if a.Method == "code" {
go func() {
<-wait.Done()
if errors.Is(wait.Err(), context.DeadlineExceeded) {
s.finish(SignInState{State: "failed", Error: "the sign-in timed out; start it again"})
}
}()
} else {
go func() {
saved, err := plugin.Finish(wait, a.Session, "")
s.pluginDone(saved, err)
}()
}
return nil
}
// deviceCode is the code a device sign-in's instructions ask to check on
// the vendor's page ("Confirm the code ABCD-EFGH on Factory's page").
var deviceCode = regexp.MustCompile(`(?i:\bcode):?\s+([A-Z0-9]+(?:-[A-Z0-9]+)+|[A-Z0-9]{6,})\b`)
// codeIn is that code, shown to copy as the built-in's was.
func codeIn(instructions string) string {
if m := deviceCode.FindStringSubmatch(instructions); m != nil {
return m[1]
}
return ""
}
// pluginCode finishes a plugin's sign-in with the code its page showed.
func (s *signInFlow) pluginCode(code string) error {
code = strings.TrimSpace(code)
if code == "" {
return errors.New("paste the code the sign-in page showed")
}
s.mu.Lock()
session := s.plugin
s.plugin = ""
waiting := s.st.State == "waiting"
s.mu.Unlock()
if session == "" || !waiting {
return errors.New("this sign-in is over; start it again")
}
ctx, cancel := context.WithTimeout(context.Background(), 2*time.Minute)
defer cancel()
saved, err := plugin.Finish(ctx, session, code)
s.pluginDone(saved, err)
return err
}
func (s *signInFlow) pluginDone(saved plugin.Saved, err error) {
switch {
case errors.Is(err, context.Canceled):
s.finish(SignInState{State: "canceled"})
case errors.Is(err, context.DeadlineExceeded):
s.finish(SignInState{State: "failed", Error: "the sign-in timed out; start it again"})
case err != nil:
s.finish(SignInState{State: "failed", Error: err.Error()})
default:
clearPluginLapse(saved)
user := pluginUser(saved)
s.finish(SignInState{State: "done", User: user, Using: pluginUsing(saved, user)})
}
}
// PluginAPIKey signs in to a plugin's provider with a key, as its "api"
// method does, beside the accounts signed in already; it gives the
// provider's magpie id.
func PluginAPIKey(ctx context.Context, id string, method int, inputs map[string]string, key string) (string, error) {
// with subscription accounts off, a key is refused as a browser
// sign-in is (StartPluginSignInWith), but for a public plugin's: one
// saved would be signed in and listed nowhere
if settings.AccountDiscoveryOff() {
if pp, ok := PluginOf(PluginID(id)); !ok || !publicPlugin(pp) {
return "", errAccountDiscoveryOff
}
}
if strings.TrimSpace(key) == "" {
pp, ok := PluginOf(PluginID(id))
if !ok || method < 0 || method >= len(pp.Methods) || pp.Methods[method].Type != "api" || !pp.Methods[method].Keyless {
return "", errors.New("enter the key")
}
}
// through the proxy the provider's requests go through (#1663)
saved, err := plugin.APIKey(Via(ctx, PluginID(id)), id, method, inputs, strings.TrimSpace(key), plugin.NewAccount)
if err != nil {
return "", err
}
return PluginSignedIn(saved), nil
}
// PluginSignedIn finishes a sign-in to a plugin's provider that magpie
// doesn't follow, a key or the command line's own, once the plugin has
// saved the account: as for one it follows (pluginDone), the account's
// lapsed mark goes and, removed from magpie, it comes back. It gives the
// provider's magpie id.
func PluginSignedIn(saved plugin.Saved) string {
clearPluginLapse(saved)
id := PluginID(saved.Provider)
_ = ShowAccount(id)
return id
}
// pluginUsing is whether the account signed in to is the one in use, the
// first, as a built-in's sign-in says.
func pluginUsing(saved plugin.Saved, user string) bool {
for _, l := range Logins(PluginID(saved.Provider)) {
if l.Active {
return user != "" && strings.EqualFold(l.User, user)
}
}
return false
}
// pluginUser is the account signed in to, as the accounts list names it.
func pluginUser(saved plugin.Saved) string {
for _, pp := range plugin.Cached() {
if pp.ID == saved.Provider {
return pluginNames(pp)[saved.Account]
}
}
return ""
}