The cross-harness, self-improving memory layer for AI agents. Join our community: https://discord.com/invite/zdNChS2fBu
Go agent-ai-cliagent-harnessesagent-securitybrowser-extensionciclaude-codecloudcodexcursordetection-engineeringjevknowledge-basememorymobile-device-managementobservabilitysecuritysecurity-information-and-event-managementsecurity-toolstelemetrytraces
bug fixes
Justin D'Souza78356f8ff4b1
diff --git a/cli/beacon/internal/auth/auth_test.go b/cli/beacon/internal/auth/auth_test.goindex 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 exchangeCodeRequestbackend := 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 := 0backend := 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.goindex 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.goindex 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.goindex 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 stringTokenPrefix string@@ -47,7 +53,8 @@ type CallbackServer struct {listener net.Listenerserver *http.ServerresultCh chan *CallbackResult- once sync.Once+ mu sync.Mutex+ completed boolstate stringcodeVerifier stringdashboardURL string@@ -60,7 +67,7 @@ func NewCallbackServer(expectedState, codeVerifier, dashboardURL string, httpClireturn 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, httpClimux.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) {