Every agent's model. One place. Codex on DeepSeek, Claude Code on Kimi, from the menu bar.
plugins: a GITHUB_TOKEN GitHub refuses is dropped for anonymous requests, not shown as an error (till on Discord)
yetone0f044e944774
diff --git a/internal/ghtoken/ghtoken.go b/internal/ghtoken/ghtoken.goindex 396aee59d..5c7dc32c7 100644--- a/internal/ghtoken/ghtoken.go+++ b/internal/ghtoken/ghtoken.go@@ -9,15 +9,23 @@// files or a mirror (source.Do sends no request with Authorization to one),// and is never written to a log or an error. The library's skills and the// Plugins page's git plugins both ask GitHub through here (#1942).+//+// A token from the environment that GitHub refuses (401) is one the user+// may not know is there, often stale: the request is asked again without+// it, and the token isn't sent again while magpie runs (till on Discord).+// The token set in Settings is the user's own choice, so a refusal of it+// is said (Refused).package ghtokenimport ("fmt"+ "io""net/http""net/url""os""strconv""strings"+ "sync""time""github.com/yetone/magpie/internal/settings"@@ -29,32 +37,95 @@ var Env = []string{"GITHUB_TOKEN", "GH_TOKEN"}// Token is the token requests to GitHub's API carry, and where it came// from: "settings", the environment variable's name, or "" for none.+// An environment variable's token GitHub refused isn't one: the next+// variable's is, or none.func Token() (token, from string) {if t := strings.TrimSpace(settings.Load().GitHubToken); t != "" {return t, "settings"}for _, k := range Env {- if t := strings.TrimSpace(os.Getenv(k)); t != "" {+ if t := strings.TrimSpace(os.Getenv(k)); t != "" && !isRefused(t) {return t, k}}return "", ""}+// refused holds the environment's tokens GitHub answered 401, for as long+// as magpie runs: keyed by the token, so a variable set to another one is+// tried afresh.+var refused = struct {+ sync.Mutex+ m map[string]bool+}{m: map[string]bool{}}++func isRefused(t string) bool {+ refused.Lock()+ defer refused.Unlock()+ return refused.m[t]+}++func markRefused(t string) {+ refused.Lock()+ refused.m[t] = true+ refused.Unlock()+}++// Do sends req with send, carrying the token as Authorize does, and says+// whether the answer given back is to a request that carried it. When+// GitHub refuses (401) a token from the environment, that token is+// dropped for the rest of the run and req is sent again without it: the+// anonymous answer is the one given back. A refused token from Settings+// is answered as GitHub answered, for the caller to say Refused().+func Do(req *http.Request, api string, send func(*http.Request) (*http.Response, error)) (*http.Response, bool, error) {+ t, from := authorize(req, api)+ resp, err := send(req)+ if err != nil || t == "" || from == "settings" || resp.StatusCode != http.StatusUnauthorized {+ return resp, t != "" && err == nil, err+ }+ again := req.Clone(req.Context())+ if req.Body != nil && req.Body != http.NoBody {+ if req.GetBody == nil {+ return resp, true, nil+ }+ b, err := req.GetBody()+ if err != nil {+ return resp, true, nil+ }+ again.Body = b+ }+ markRefused(t)+ io.Copy(io.Discard, io.LimitReader(resp.Body, 64<<10))+ resp.Body.Close()+ again.Header.Del("Authorization")+ resp, err = send(again)+ return resp, false, err+}+// Authorize has req carry the token, if there is one and req goes to the// host of api (GitHub's API's base URL, which tests move); it says whether// it did.+//+// Do is Authorize with an environment token GitHub refuses dropped for an+// anonymous request; a caller sends through it rather than this.func Authorize(req *http.Request, api string) bool {+ t, _ := authorize(req, api)+ return t != ""+}++// authorize is Authorize, saying which token req carries and where it came+// from, or "" for none.+func authorize(req *http.Request, api string) (token, from string) {u, err := url.Parse(api)if err != nil || u.Host == "" || req.URL == nil || req.URL.Host == "" || !strings.EqualFold(req.URL.Host, u.Host) {- return false+ return "", ""}- t, _ := Token()+ t, from := Token()if t == "" {- return false+ return "", ""}req.Header.Set("Authorization", "Bearer "+t)- return true+ return t, from}// Refused is the error for a 401 from GitHub to a request that carried thediff --git a/internal/ghtoken/ghtoken_test.go b/internal/ghtoken/ghtoken_test.gonew file mode 100644index 000000000..3822814a2--- /dev/null+++ b/internal/ghtoken/ghtoken_test.go@@ -0,0 +1,184 @@+package ghtoken++import (+ "errors"+ "fmt"+ "io"+ "net/http"+ "net/http/httptest"+ "strings"+ "sync"+ "testing"++ "github.com/yetone/magpie/internal/settings"+)++// fakeAPI is GitHub's API answering 401 to every token but good, and+// answer (200 when nil) otherwise; it keeps the Authorization of each+// request.+type fakeAPI struct {+ *httptest.Server+ mu sync.Mutex+ auth []string+ good string+ answer func(w http.ResponseWriter)+}++func newFakeAPI(t *testing.T) *fakeAPI {+ f := &fakeAPI{}+ f.Server = httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {+ a := r.Header.Get("Authorization")+ f.mu.Lock()+ f.auth = append(f.auth, a)+ good, answer := f.good, f.answer+ f.mu.Unlock()+ if a != "" && a != "Bearer "+good {+ w.WriteHeader(401)+ fmt.Fprint(w, `{"message":"Bad credentials"}`)+ return+ }+ if answer != nil {+ answer(w)+ return+ }+ fmt.Fprint(w, `{"ok":true}`)+ }))+ t.Cleanup(f.Close)+ return f+}++func (f *fakeAPI) asked() []string {+ f.mu.Lock()+ defer f.mu.Unlock()+ return append([]string(nil), f.auth...)+}++func (f *fakeAPI) get(t *testing.T) (*http.Response, bool, []byte) {+ t.Helper()+ req, _ := http.NewRequest("GET", f.URL+"/repos/o/r/commits", nil)+ resp, token, err := Do(req, f.URL, http.DefaultClient.Do)+ if err != nil {+ t.Fatal(err)+ }+ defer resp.Body.Close()+ b, _ := io.ReadAll(resp.Body)+ return resp, token, b+}++func setToken(t *testing.T, settingsTok, githubTok, ghTok string) {+ t.Helper()+ s := settings.Load()+ s.GitHubToken = settingsTok+ if err := settings.Save(s); err != nil {+ t.Fatal(err)+ }+ t.Setenv("GITHUB_TOKEN", githubTok)+ t.Setenv("GH_TOKEN", ghTok)+}++// till on Discord: a stale GITHUB_TOKEN in the environment made the+// Plugins page say "GitHub refused GITHUB_TOKEN" while GitHub answered+// fine without it. The request is asked again without the token, and the+// anonymous answer is the one given back.+func TestEnvTokenRefusedAskedAgainWithout(t *testing.T) {+ f := newFakeAPI(t)+ setToken(t, "", "stale-env-retry", "")+ resp, token, body := f.get(t)+ if resp.StatusCode != 200 || token || string(body) != `{"ok":true}` {+ t.Fatalf("got %d token=%v %s", resp.StatusCode, token, body)+ }+ if a := f.asked(); len(a) != 2 || a[0] != "Bearer stale-env-retry" || a[1] != "" {+ t.Errorf("GitHub was asked with %q, want the token then none", a)+ }+}++// Once refused, the environment's token isn't sent again: the next+// request goes without it at once, and Token says there is none.+func TestEnvTokenRefusedNotSentAgain(t *testing.T) {+ f := newFakeAPI(t)+ setToken(t, "", "stale-env-once", "")+ f.get(t)+ n := len(f.asked())+ resp, token, _ := f.get(t)+ if resp.StatusCode != 200 || token {+ t.Fatalf("second request: %d token=%v", resp.StatusCode, token)+ }+ if a := f.asked()[n:]; len(a) != 1 || a[0] != "" {+ t.Errorf("after the refusal GitHub was asked with %q, want one request without a token", a)+ }+ if tok, from := Token(); tok != "" || from != "" {+ t.Errorf("Token() = %q from %q after its refusal", tok, from)+ }+ // GH_TOKEN, a different token, is still tried+ t.Setenv("GH_TOKEN", "good-gh")+ f.mu.Lock()+ f.good = "good-gh"+ f.mu.Unlock()+ if _, token, _ := f.get(t); !token {+ t.Error("GH_TOKEN wasn't sent after GITHUB_TOKEN was refused")+ }+}++// The token set in Settings is the user's own choice: its refusal comes+// back as GitHub's 401, asked once, and Refused names it.+func TestSettingsTokenRefusedStaysAnError(t *testing.T) {+ f := newFakeAPI(t)+ setToken(t, "ghp_settings_bad", "", "")+ resp, token, _ := f.get(t)+ if resp.StatusCode != 401 || !token {+ t.Fatalf("got %d token=%v, want 401 with the token", resp.StatusCode, token)+ }+ if a := f.asked(); len(a) != 1 || a[0] != "Bearer ghp_settings_bad" {+ t.Errorf("GitHub was asked with %q", a)+ }+ err := Refused()+ if !strings.Contains(err.Error(), "the GitHub token in Settings") || strings.Contains(err.Error(), "ghp_settings_bad") {+ t.Errorf("Refused() = %v", err)+ }+ // and it is sent again next time: Settings' token is never dropped+ f.get(t)+ if a := f.asked(); len(a) != 2 || a[1] != "Bearer ghp_settings_bad" {+ t.Errorf("Settings' token wasn't sent again: %q", a)+ }+}++// The anonymous request, rate limited, is said as GitHub's limit for+// requests without a token, as before.+func TestEnvTokenRefusedThenAnonymousLimited(t *testing.T) {+ f := newFakeAPI(t)+ f.answer = func(w http.ResponseWriter) {+ w.Header().Set("X-RateLimit-Remaining", "0")+ w.Header().Set("X-RateLimit-Reset", "1893553440")+ w.WriteHeader(403)+ fmt.Fprint(w, `{"message":"API rate limit exceeded for 1.2.3.4."}`)+ }+ setToken(t, "", "", "stale-env-limited")+ resp, token, body := f.get(t)+ e, ok := LimitedBy(resp, body, token)+ if !ok || e.Token || e.Until.IsZero() {+ t.Fatalf("LimitedBy = %+v %v (status %d)", e, ok, resp.StatusCode)+ }+ var l Limited+ if err := error(e); !errors.As(err, &l) || !strings.Contains(err.Error(), "60 an hour") {+ t.Errorf("limit said as %q", err)+ }+}++// A request to another host never carries the token, and its 401 is left+// as it is.+func TestOtherHostUntouched(t *testing.T) {+ f := newFakeAPI(t)+ setToken(t, "", "env-other-host", "")+ req, _ := http.NewRequest("GET", f.URL+"/x", nil)+ resp, token, err := Do(req, "https://api.github.invalid", http.DefaultClient.Do)+ if err != nil {+ t.Fatal(err)+ }+ resp.Body.Close()+ if token || resp.StatusCode != 200 {+ t.Errorf("got %d token=%v", resp.StatusCode, token)+ }+ if a := f.asked(); len(a) != 1 || a[0] != "" {+ t.Errorf("another host was asked with %q", a)+ }+}diff --git a/internal/ghtoken/main_test.go b/internal/ghtoken/main_test.gonew file mode 100644index 000000000..4d956f627--- /dev/null+++ b/internal/ghtoken/main_test.go@@ -0,0 +1,10 @@+package ghtoken++import (+ "testing"++ "github.com/yetone/magpie/internal/testenv"+)++// The tests run in a home of their own, so Settings is theirs.+func TestMain(m *testing.M) { testenv.Main(m) }diff --git a/internal/library/github.go b/internal/library/github.goindex d8554f815..c0e7cfe4a 100644--- a/internal/library/github.go+++ b/internal/library/github.go@@ -24,6 +24,14 @@ func GitHubToken() (token, from string) { return ghtoken.Token() }// GitHub's API (githubAPI's host); it says whether it did.func withGitHubToken(req *http.Request) bool { return ghtoken.Authorize(req, githubAPI) }+// doGitHub sends req with send, carrying the token as withGitHubToken+// does, and says whether the answer is to a request that carried it: an+// environment token GitHub refuses is dropped and req sent again without+// it (ghtoken.Do).+func doGitHub(req *http.Request, send func(*http.Request) (*http.Response, error)) (*http.Response, bool, error) {+ return ghtoken.Do(req, githubAPI, send)+}+// errLimited is GitHub turning requests away for a while.type errLimited = ghtoken.Limiteddiff --git a/internal/library/github_test.go b/internal/library/github_test.goindex ebf316245..cd983e2b3 100644--- a/internal/library/github_test.go+++ b/internal/library/github_test.go@@ -201,8 +201,11 @@ func TestGitHubRateLimitSaid(t *testing.T) {t.Errorf("secondary limit: %+v %+v", c, c.Limited)}- // a token GitHub refuses says which one+ // a token GitHub refuses says which one when it is Settings'g.answer = func(w http.ResponseWriter, r *http.Request) bool {+ if r.Header.Get("Authorization") == "" {+ return false+ }w.WriteHeader(401)fmt.Fprint(w, `{"message":"Bad credentials"}`)return true@@ -211,12 +214,36 @@ func TestGitHubRateLimitSaid(t *testing.T) {if c.Limited != nil || c.Error != "GitHub refused the GitHub token in Settings → Network and sharing: it may have expired or been revoked" {t.Errorf("refused: %+v", c)}+ // one from the environment (till on Discord: a stale GITHUB_TOKEN)+ // is dropped: the check is asked again without it, and isn't sent+ // againsetGitHubToken(t, "")- t.Setenv("GH_TOKEN", "bad")+ t.Setenv("GH_TOKEN", "bad-env-skills")+ g.mu.Lock()+ n := len(g.apiAuth)+ g.mu.Unlock()c = check(t)["pdf"]- if !strings.Contains(c.Error, "GitHub refused GH_TOKEN") || strings.Contains(c.Error, "bad") {+ if c.Error != "" || c.Limited != nil || c.Commit == "" {t.Errorf("refused from the environment: %+v", c)}+ g.mu.Lock()+ if a := g.apiAuth[n:]; len(a) < 2 || a[0] != "Bearer bad-env-skills" || a[1] != "" {+ t.Errorf("refused from the environment: GitHub was asked with %q, want the token then none", a)+ }+ n = len(g.apiAuth)+ g.mu.Unlock()+ c = check(t)["pdf"]+ if c.Error != "" || c.Commit == "" {+ t.Errorf("refused from the environment, checked again: %+v", c)+ }+ g.mu.Lock()+ defer g.mu.Unlock()+ for _, a := range g.apiAuth[n:] {+ if a != "" {+ t.Errorf("the refused GH_TOKEN was sent again: %q", g.apiAuth[n:])+ break+ }+ }}// A folder asked about again is asked with the ETag GitHub gave, and itsdiff --git a/internal/library/rtk_upgrade.go b/internal/library/rtk_upgrade.goindex aebf13be4..6a894d7df 100644--- a/internal/library/rtk_upgrade.go+++ b/internal/library/rtk_upgrade.go@@ -284,9 +284,8 @@ func latestRTK() (string, error) {}req, _ = http.NewRequest("GET", rtkReleasesAPI, nil)req.Header.Set("User-Agent", "magpie")- withGitHubToken(req)req.Header.Set("Accept", "application/vnd.github+json")- resp, err := source.Do(c, req)+ resp, _, err := doGitHub(req, func(r *http.Request) (*http.Response, error) { return source.Do(c, r) })if err != nil {return "", err}diff --git a/internal/library/skillcheck.go b/internal/library/skillcheck.goindex ce799af04..d0e25d6b7 100644--- a/internal/library/skillcheck.go+++ b/internal/library/skillcheck.go@@ -162,7 +162,6 @@ func apiGet(u string) ([]byte, int, bool, error) {req, _ := http.NewRequest("GET", u, nil)req.Header.Set("User-Agent", "magpie")req.Header.Set("Accept", "application/vnd.github+json")- token := withGitHubToken(req)etags.Lock()had, cached := etags.m[u]etags.Unlock()@@ -170,7 +169,7 @@ func apiGet(u string) ([]byte, int, bool, error) {req.Header.Set("If-None-Match", had.etag)}c := &http.Client{Timeout: 20 * time.Second}- resp, err := source.Do(c, req)+ resp, token, err := doGitHub(req, func(r *http.Request) (*http.Response, error) { return source.Do(c, r) })if err != nil {return nil, 0, token, fmt.Errorf("couldn't reach GitHub: %w", err)}diff --git a/internal/library/skills.go b/internal/library/skills.goindex 2a6adc257..34afbda5c 100644--- a/internal/library/skills.go+++ b/internal/library/skills.go@@ -770,9 +770,7 @@ func fetch(src Source) (string, error) {get := func(u string) (*http.Response, bool, error) {req, _ := http.NewRequest("GET", u, nil)req.Header.Set("User-Agent", "magpie")- token := withGitHubToken(req)- resp, err := source.DoOfficial(c, req)- return resp, token, err+ return doGitHub(req, func(r *http.Request) (*http.Response, error) { return source.DoOfficial(c, r) })}if tooBig.has(src) {return fetchSkillFiles(src)diff --git a/internal/library/skilltree.go b/internal/library/skilltree.goindex 06baa0acc..a4da72b65 100644--- a/internal/library/skilltree.go+++ b/internal/library/skilltree.go@@ -253,8 +253,9 @@ func fetchBlob(c *http.Client, src Source, path, sha, dst string, exec bool) errif accept != "" {req.Header.Set("Accept", accept)}- token = withGitHubToken(req)- return source.DoOfficial(c, req)+ resp, t, err := doGitHub(req, func(r *http.Request) (*http.Response, error) { return source.DoOfficial(c, r) })+ token = t+ return resp, err}resp, err := get(rawURL(src.Repo, src.Ref, path), "")if err != nil {diff --git a/internal/plugin/bun.go b/internal/plugin/bun.goindex a309879ad..f32e95389 100644--- a/internal/plugin/bun.go+++ b/internal/plugin/bun.go@@ -285,13 +285,12 @@ func getURLFrom(ctx context.Context, url string, limit int64, mirror bool) ([]by}// Bun's newest release is asked of GitHub's API: with the user's// GitHub token, as every request magpie makes to it is (#1942)- ghtoken.Authorize(req, githubAPI)- var res *http.Response- if mirror {- res, err = source.Do(http.DefaultClient, req)- } else {- res, err = source.DoOfficial(http.DefaultClient, req)- }+ res, _, err := ghtoken.Do(req, githubAPI, func(r *http.Request) (*http.Response, error) {+ if mirror {+ return source.Do(http.DefaultClient, r)+ }+ return source.DoOfficial(http.DefaultClient, r)+ })if err != nil {return nil, err}diff --git a/internal/plugin/github_test.go b/internal/plugin/github_test.goindex bc79fb622..f88667693 100644--- a/internal/plugin/github_test.go+++ b/internal/plugin/github_test.go@@ -93,6 +93,11 @@ func fakeGitHub(t *testing.T, up *atomic.Bool, asked *atomic.Int32) {if h := holding.Load(); h != nil && q.URL.Path == h.path {<-h.go_}+ if q.Header.Get("Authorization") == "Bearer "+staleToken {+ w.WriteHeader(401)+ w.Write([]byte(`{"message":"Bad credentials"}`))+ return+ }if !up.Load() || q.URL.Path == "/raw/someone/flaky-entry/main/index.js" {http.Error(w, "down", 503)return@@ -486,6 +491,27 @@ func TestPkgEntry(t *testing.T) {// couldn't be read and why, not that none are tagged (till on Discord:// on their desktop the section wasn't there, on their server it had many).// One read before is kept and isn't counted.+// staleToken is a token fakeGitHub answers 401, as GitHub does an+// expired one.+const staleToken = "stale-till"++// till on Discord: a stale GITHUB_TOKEN in the environment, which GitHub+// refuses, left the Plugins page's GitHub section saying "GitHub refused+// GITHUB_TOKEN" while GitHub answered fine without it. The search is+// asked again without the token, and the list is GitHub's.+func TestTaggedReposStaleEnvTokenDropped(t *testing.T) {+ var up atomic.Bool+ var asked atomic.Int32+ up.Store(true)+ fakeGitHub(t, &up, &asked)+ t.Setenv("GITHUB_TOKEN", staleToken)+ t.Setenv("GH_TOKEN", "")+ l, err := TaggedRepos(context.Background())+ if err != nil || len(l) != 7 {+ t.Fatalf("with a stale GITHUB_TOKEN: %v, %d repos", err, len(l))+ }+}+func TestTaggedReposUnreadable(t *testing.T) {var up atomic.Boolvar asked atomic.Int32diff --git a/internal/plugin/github_token_test.go b/internal/plugin/github_token_test.goindex 02a39b0d5..8d6a302f2 100644--- a/internal/plugin/github_token_test.go+++ b/internal/plugin/github_token_test.go@@ -30,7 +30,7 @@ func TestGitPluginCheckCarriesGitHubToken(t *testing.T) {var mu sync.Mutexvar auth []string- var answer func(w http.ResponseWriter) bool+ var answer func(w http.ResponseWriter, r *http.Request) boolapi := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {mu.Lock()auth = append(auth, r.Header.Get("Authorization"))@@ -40,7 +40,7 @@ func TestGitPluginCheckCarriesGitHubToken(t *testing.T) {http.NotFound(w, r)return}- if a != nil && a(w) {+ if a != nil && a(w, r) {return}fmt.Fprint(w, `[{"sha":"abc1234def5678abc1234def5678abc1234def56"}]`)@@ -109,7 +109,7 @@ func TestGitPluginCheckCarriesGitHubToken(t *testing.T) {// the rate limit used up: said, with when it lifts, the token neverreset := time.Date(2030, 1, 2, 3, 4, 0, 0, time.UTC)mu.Lock()- answer = func(w http.ResponseWriter) bool {+ answer = func(w http.ResponseWriter, r *http.Request) bool {w.Header().Set("X-RateLimit-Remaining", "0")w.Header().Set("X-RateLimit-Reset", fmt.Sprint(reset.Unix()))w.WriteHeader(403)@@ -132,7 +132,7 @@ func TestGitPluginCheckCarriesGitHubToken(t *testing.T) {}// a secondary limit: 429 with Retry-Aftermu.Lock()- answer = func(w http.ResponseWriter) bool {+ answer = func(w http.ResponseWriter, r *http.Request) bool {w.Header().Set("Retry-After", "60")w.WriteHeader(429)return true@@ -142,18 +142,46 @@ func TestGitPluginCheckCarriesGitHubToken(t *testing.T) {t.Errorf("secondary limit: %+v %+v", c, c.Limited)}- // a token GitHub refuses: which one, not the token- t.Setenv("GH_TOKEN", "bad-token")+ // a token GitHub refuses (401), answering without one: the token in+ // Settings is said, by where it is, not the tokenmu.Lock()- answer = func(w http.ResponseWriter) bool {+ answer = func(w http.ResponseWriter, r *http.Request) bool {+ if r.Header.Get("Authorization") == "" {+ return false+ }w.WriteHeader(401)fmt.Fprint(w, `{"message":"Bad credentials"}`)return true}mu.Unlock()- if c = check(); c.Limited != nil || !strings.Contains(c.Error, "GitHub refused GH_TOKEN") || strings.Contains(c.Error, "bad-token") {- t.Errorf("refused: %+v", c)+ setToken("ghp_settings_refused")+ if c = check(); c.Limited != nil || !strings.Contains(c.Error, "GitHub refused the GitHub token in Settings") || strings.Contains(c.Error, "ghp_settings_refused") {+ t.Errorf("Settings' token refused: %+v", c)+ }+ setToken("")+ // one from the environment (till on Discord: a stale GITHUB_TOKEN) is+ // dropped, and the check asked again without it+ t.Setenv("GH_TOKEN", "bad-token")+ mu.Lock()+ n := len(auth)+ mu.Unlock()+ if c = check(); c.Status != "current" || c.Error != "" {+ t.Errorf("GH_TOKEN refused: %+v", c)+ }+ mu.Lock()+ if a := auth[n:]; len(a) != 2 || a[0] != "Bearer bad-token" || a[1] != "" {+ t.Errorf("GH_TOKEN refused: GitHub was asked with %q, want the token then none", a)+ }+ n = len(auth)+ mu.Unlock()+ if c = check(); c.Status != "current" {+ t.Errorf("GH_TOKEN refused, checked again: %+v", c)}+ mu.Lock()+ if a := auth[n:]; len(a) != 1 || a[0] != "" {+ t.Errorf("GH_TOKEN refused, checked again: GitHub was asked with %q, want none", a)+ }+ mu.Unlock()// another host (raw files) never gets the tokenvar rawAuth stringdiff --git a/internal/plugin/market.go b/internal/plugin/market.goindex 0fb1b1ada..e4ced05fe 100644--- a/internal/plugin/market.go+++ b/internal/plugin/market.go@@ -241,9 +241,12 @@ func fetchJSONFrom(ctx context.Context, u string, limit int64, do func(*http.Clireq.Header.Set("Accept", "application/json")// GitHub's API is asked with the user's GitHub token, as the// library's skills are: without one it answers an address 60- // requests an hour, which a few git plugins' checks use up (#1942)- token := ghtoken.Authorize(req, githubAPI)- res, err := do(http.DefaultClient, req)+ // requests an hour, which a few git plugins' checks use up (#1942);+ // an environment token GitHub refuses is dropped for an anonymous+ // request (till on Discord)+ res, token, err := ghtoken.Do(req, githubAPI, func(r *http.Request) (*http.Response, error) {+ return do(http.DefaultClient, r)+ })if err != nil {return nil, err}