Skip to content

The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu

bug fixes

Justin D'Souza78356f8ff4b1
diff --git a/cli/beacon/internal/auth/auth_test.go b/cli/beacon/internal/auth/auth_test.go
index 9c9a4c53..6d4ee263 100644
--- a/cli/beacon/internal/auth/auth_test.go
+++ b/cli/beacon/internal/auth/auth_test.go
@@ -105,6 +105,31 @@ func TestIsLoggedInRejectsExpiredCredentials(t *testing.T) {
}
}
+func TestIsLoggedInRejectsIncompleteCredentials(t *testing.T) {
+ for name, contents := range map[string]string{
+ "missing token": `{"token":"","user_id":"user-1"}`,
+ "missing user ID": `{"token":"secret-token","user_id":""}`,
+ } {
+ t.Run(name, func(t *testing.T) {
+ home := t.TempDir()
+ t.Setenv("HOME", home)
+ if _, err := EnsureConfigDir(); err != nil {
+ t.Fatalf("EnsureConfigDir returned error: %v", err)
+ }
+ path, err := CredentialsPath()
+ if err != nil {
+ t.Fatalf("CredentialsPath returned error: %v", err)
+ }
+ if err := os.WriteFile(path, []byte(contents), 0600); err != nil {
+ t.Fatalf("write credentials: %v", err)
+ }
+ if IsLoggedIn() {
+ t.Fatal("IsLoggedIn = true, want false for incomplete credentials")
+ }
+ })
+ }
+}
+
func TestCallbackServerExchangesCodeForToken(t *testing.T) {
var gotRequest exchangeCodeRequest
backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
@@ -157,36 +182,138 @@ func TestCallbackServerExchangesCodeForToken(t *testing.T) {
}
}
-func TestCallbackServerRejectsStateMismatch(t *testing.T) {
- backendCalled := false
+func TestCallbackServerWriteTimeoutAllowsDefaultExchangeTimeout(t *testing.T) {
+ server, err := NewCallbackServer("state-123", "verifier-123", "https://dashboard.example", nil)
+ if err != nil {
+ t.Fatalf("NewCallbackServer returned error: %v", err)
+ }
+ defer func() { _ = server.Shutdown() }()
+
+ if server.httpClient.Timeout != defaultExchangeTimeout {
+ t.Fatalf("default exchange timeout = %s, want %s", server.httpClient.Timeout, defaultExchangeTimeout)
+ }
+ if server.server.WriteTimeout <= server.httpClient.Timeout {
+ t.Fatalf("callback write timeout = %s, want greater than exchange timeout %s", server.server.WriteTimeout, server.httpClient.Timeout)
+ }
+}
+
+func TestLoginRejectsIncompleteExchangeResponse(t *testing.T) {
+ for name, tc := range map[string]struct {
+ responseBody string
+ wantErr string
+ }{
+ "missing token": {
+ responseBody: `{"token":"","token_prefix":"asym_123","user_id":"user-1","email":"[email protected]"}`,
+ wantErr: "credentials token is required",
+ },
+ "missing user ID": {
+ responseBody: `{"token":"secret-token","token_prefix":"asym_123","user_id":"","email":"[email protected]"}`,
+ wantErr: "credentials user ID is required",
+ },
+ } {
+ t.Run(name, func(t *testing.T) {
+ backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = w.Write([]byte(tc.responseBody))
+ }))
+ defer backend.Close()
+
+ callbackErr := make(chan error, 1)
+ openBrowser := func(authURL string) error {
+ u, err := url.Parse(authURL)
+ if err != nil {
+ return err
+ }
+ callbackURL := url.URL{
+ Scheme: "http",
+ Host: "127.0.0.1:" + u.Query().Get("port"),
+ Path: "/callback",
+ RawQuery: "exchange_code=code-123&state=" + url.QueryEscape(u.Query().Get("state")),
+ }
+ go func() {
+ resp, err := http.Get(callbackURL.String())
+ if err == nil {
+ _ = resp.Body.Close()
+ }
+ callbackErr <- err
+ }()
+ return nil
+ }
+
+ creds, err := Login(LoginOptions{
+ DashboardURL: backend.URL,
+ HTTPClient: backend.Client(),
+ OpenBrowser: openBrowser,
+ Timeout: 2 * time.Second,
+ })
+ if err == nil {
+ t.Fatal("Login error = nil, want error")
+ }
+ if creds != nil {
+ t.Fatalf("Login credentials = %#v, want nil", creds)
+ }
+ if !strings.Contains(err.Error(), tc.wantErr) {
+ t.Fatalf("Login error = %q, want to contain %q", err, tc.wantErr)
+ }
+ if err := <-callbackErr; err != nil {
+ t.Fatalf("callback request failed: %v", err)
+ }
+ })
+ }
+}
+
+func TestCallbackServerIgnoresInvalidCallbacksBeforeValidRedirect(t *testing.T) {
+ backendCalls := 0
backend := httptest.NewServer(http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
- backendCalled = true
- t.Fatal("backend should not be called on state mismatch")
+ backendCalls++
+ if r.URL.Path != "/api/cli/auth/exchange" {
+ t.Fatalf("exchange path = %q, want /api/cli/auth/exchange", r.URL.Path)
+ }
+ w.Header().Set("Content-Type", "application/json")
+ _, _ = w.Write([]byte(`{"token":"secret-token","token_prefix":"asym_123","user_id":"user-1","email":"[email protected]","org_id":"org-1","org_name":"Example Org"}`))
}))
defer backend.Close()
- server, err := NewCallbackServer("expected-state", "verifier", backend.URL, backend.Client())
+ server, err := NewCallbackServer("expected-state", "verifier-123", backend.URL, backend.Client())
if err != nil {
t.Fatalf("NewCallbackServer returned error: %v", err)
}
defer func() { _ = server.Shutdown() }()
server.Start()
- go func() {
- resp, err := http.Get("http://127.0.0.1:" + strconv.Itoa(server.Port()) + "/callback?exchange_code=code&state=wrong-state")
+ baseURL := "http://127.0.0.1:" + strconv.Itoa(server.Port()) + "/callback"
+ for _, rawURL := range []string{
+ baseURL + "?exchange_code=code&state=wrong-state",
+ baseURL + "?state=expected-state",
+ baseURL + "?error=access_denied",
+ } {
+ resp, err := http.Get(rawURL)
if err == nil {
_ = resp.Body.Close()
}
- }()
+ }
+ if backendCalls != 0 {
+ t.Fatalf("backend calls after invalid callbacks = %d, want 0", backendCalls)
+ }
+
+ resp, err := http.Get(baseURL + "?exchange_code=code-123&state=expected-state")
+ if err != nil {
+ t.Fatalf("valid callback request failed: %v", err)
+ }
+ _ = resp.Body.Close()
+
result, err := server.Wait(2 * time.Second)
if err != nil {
t.Fatalf("Wait returned error: %v", err)
}
- if !strings.Contains(result.Error, "state mismatch") {
- t.Fatalf("result error = %q, want state mismatch", result.Error)
+ if result.Error != "" {
+ t.Fatalf("callback result error = %q", result.Error)
+ }
+ if result.Token != "secret-token" || result.State != "expected-state" {
+ t.Fatalf("unexpected callback result: %#v", result)
}
- if backendCalled {
- t.Fatal("backend was called on state mismatch")
+ if backendCalls != 1 {
+ t.Fatalf("backend calls = %d, want 1", backendCalls)
}
}
diff --git a/cli/beacon/internal/auth/credentials.go b/cli/beacon/internal/auth/credentials.go
index 7cee30a3..979a620f 100644
--- a/cli/beacon/internal/auth/credentials.go
+++ b/cli/beacon/internal/auth/credentials.go
@@ -5,6 +5,7 @@ import (
"fmt"
"os"
"path/filepath"
+ "strings"
"time"
)
@@ -55,6 +56,9 @@ func SaveCredentials(creds *Credentials) error {
if creds == nil {
return fmt.Errorf("credentials are required")
}
+ if err := creds.validateRequiredFields(); err != nil {
+ return err
+ }
if _, err := EnsureConfigDir(); err != nil {
return fmt.Errorf("failed to create auth directory: %w", err)
}
@@ -110,7 +114,20 @@ func IsLoggedIn() bool {
if err != nil || creds == nil {
return false
}
- return !creds.IsExpired()
+ return creds.validateRequiredFields() == nil && !creds.IsExpired()
+}
+
+func (c *Credentials) validateRequiredFields() error {
+ if c == nil {
+ return fmt.Errorf("credentials are required")
+ }
+ if strings.TrimSpace(c.Token) == "" {
+ return fmt.Errorf("credentials token is required")
+ }
+ if strings.TrimSpace(c.UserID) == "" {
+ return fmt.Errorf("credentials user ID is required")
+ }
+ return nil
}
func (c *Credentials) IsExpired() bool {
diff --git a/cli/beacon/internal/auth/login.go b/cli/beacon/internal/auth/login.go
index 89eb0378..b2703d08 100644
--- a/cli/beacon/internal/auth/login.go
+++ b/cli/beacon/internal/auth/login.go
@@ -80,7 +80,7 @@ func Login(opts LoginOptions) (*Credentials, error) {
}
}
}
- return &Credentials{
+ creds := &Credentials{
Token: result.Token,
TokenPrefix: result.TokenPrefix,
ExpiresAt: expiresAt,
@@ -88,7 +88,11 @@ func Login(opts LoginOptions) (*Credentials, error) {
Email: result.Email,
OrgID: result.OrgID,
OrgName: result.OrgName,
- }, nil
+ }
+ if err := creds.validateRequiredFields(); err != nil {
+ return nil, fmt.Errorf("invalid authentication response: %w", err)
+ }
+ return creds, nil
}
func ResolveDashboardURL(flagValue string) string {
diff --git a/cli/beacon/internal/auth/server.go b/cli/beacon/internal/auth/server.go
index f40db597..cd5143d1 100644
--- a/cli/beacon/internal/auth/server.go
+++ b/cli/beacon/internal/auth/server.go
@@ -14,6 +14,12 @@ import (
"time"
)
+const (
+ callbackReadTimeout = 10 * time.Second
+ defaultExchangeTimeout = 30 * time.Second
+ callbackWriteTimeoutSlack = 5 * time.Second
+)
+
type CallbackResult struct {
Token string
TokenPrefix string
@@ -47,7 +53,8 @@ type CallbackServer struct {
listener net.Listener
server *http.Server
resultCh chan *CallbackResult
- once sync.Once
+ mu sync.Mutex
+ completed bool
state string
codeVerifier string
dashboardURL string
@@ -60,7 +67,7 @@ func NewCallbackServer(expectedState, codeVerifier, dashboardURL string, httpCli
return nil, fmt.Errorf("failed to start callback server: %w", err)
}
if httpClient == nil {
- httpClient = &http.Client{Timeout: 30 * time.Second}
+ httpClient = &http.Client{Timeout: defaultExchangeTimeout}
}
cs := &CallbackServer{
port: listener.Addr().(*net.TCPAddr).Port,
@@ -75,13 +82,21 @@ func NewCallbackServer(expectedState, codeVerifier, dashboardURL string, httpCli
mux.HandleFunc("/callback", cs.handleCallback)
cs.server = &http.Server{
Handler: mux,
- ReadHeaderTimeout: 10 * time.Second,
- ReadTimeout: 10 * time.Second,
- WriteTimeout: 10 * time.Second,
+ ReadHeaderTimeout: callbackReadTimeout,
+ ReadTimeout: callbackReadTimeout,
+ WriteTimeout: callbackWriteTimeout(httpClient),
}
return cs, nil
}
+func callbackWriteTimeout(httpClient *http.Client) time.Duration {
+ exchangeTimeout := defaultExchangeTimeout
+ if httpClient != nil && httpClient.Timeout > exchangeTimeout {
+ exchangeTimeout = httpClient.Timeout
+ }
+ return exchangeTimeout + callbackWriteTimeoutSlack
+}
+
func (cs *CallbackServer) Port() int {
return cs.port
}
@@ -110,47 +125,65 @@ func (cs *CallbackServer) Shutdown() error {
}
func (cs *CallbackServer) handleCallback(w http.ResponseWriter, r *http.Request) {
- cs.once.Do(func() {
- query := r.URL.Query()
- if errMsg := query.Get("error"); errMsg != "" {
- cs.resultCh <- &CallbackResult{Error: errMsg}
- cs.sendResponse(w, false, errMsg)
- return
- }
- state := query.Get("state")
- if state != cs.state {
- cs.resultCh <- &CallbackResult{Error: "state mismatch - possible CSRF attack"}
- cs.sendResponse(w, false, "Security error: state mismatch")
- return
- }
- exchangeCode := query.Get("exchange_code")
- if exchangeCode == "" {
- cs.resultCh <- &CallbackResult{Error: "no exchange code received"}
- cs.sendResponse(w, false, "No exchange code received")
- return
- }
- tokenResp, err := cs.exchangeCodeForToken(r.Context(), exchangeCode, state, cs.codeVerifier)
- if err != nil {
- message := fmt.Sprintf("failed to exchange code: %v", err)
- cs.resultCh <- &CallbackResult{Error: message}
- cs.sendResponse(w, false, message)
- return
- }
- result := &CallbackResult{
- Token: tokenResp.Token,
- TokenPrefix: tokenResp.TokenPrefix,
- UserID: tokenResp.UserID,
- Email: tokenResp.Email,
- OrgID: tokenResp.OrgID,
- OrgName: tokenResp.OrgName,
- State: state,
- }
- if tokenResp.ExpiresAt != nil {
- result.ExpiresAt = *tokenResp.ExpiresAt
- }
- cs.resultCh <- result
- cs.sendResponse(w, true, "")
- })
+ query := r.URL.Query()
+ state := query.Get("state")
+ if state != cs.state {
+ cs.sendResponse(w, false, "Security error: state mismatch")
+ return
+ }
+ if errMsg := query.Get("error"); errMsg != "" {
+ cs.finishCallback(w, &CallbackResult{Error: errMsg}, false, errMsg)
+ return
+ }
+ exchangeCode := query.Get("exchange_code")
+ if exchangeCode == "" {
+ cs.sendResponse(w, false, "No exchange code received")
+ return
+ }
+ if !cs.reserveCompletion() {
+ cs.sendResponse(w, false, "Authentication callback already handled")
+ return
+ }
+ tokenResp, err := cs.exchangeCodeForToken(r.Context(), exchangeCode, state, cs.codeVerifier)
+ if err != nil {
+ message := fmt.Sprintf("failed to exchange code: %v", err)
+ cs.resultCh <- &CallbackResult{Error: message}
+ cs.sendResponse(w, false, message)
+ return
+ }
+ result := &CallbackResult{
+ Token: tokenResp.Token,
+ TokenPrefix: tokenResp.TokenPrefix,
+ UserID: tokenResp.UserID,
+ Email: tokenResp.Email,
+ OrgID: tokenResp.OrgID,
+ OrgName: tokenResp.OrgName,
+ State: state,
+ }
+ if tokenResp.ExpiresAt != nil {
+ result.ExpiresAt = *tokenResp.ExpiresAt
+ }
+ cs.resultCh <- result
+ cs.sendResponse(w, true, "")
+}
+
+func (cs *CallbackServer) finishCallback(w http.ResponseWriter, result *CallbackResult, success bool, errorMsg string) {
+ if !cs.reserveCompletion() {
+ cs.sendResponse(w, false, "Authentication callback already handled")
+ return
+ }
+ cs.resultCh <- result
+ cs.sendResponse(w, success, errorMsg)
+}
+
+func (cs *CallbackServer) reserveCompletion() bool {
+ cs.mu.Lock()
+ defer cs.mu.Unlock()
+ if cs.completed {
+ return false
+ }
+ cs.completed = true
+ return true
}
func (cs *CallbackServer) exchangeCodeForToken(ctx context.Context, exchangeCode, state, codeVerifier string) (*exchangeCodeResponse, error) {