The problem: My initial isRetryable checked exit codes, but the backend returns

  ERR_DB_ASYNC_TABLE_NOT_SETUP as a 5xx, which mapped to ExitGenericError — falsely treated as
  retryable.

  The real fix: The OperationalError is now preserved in the error chain (not flattened to a
  string), so isRetryable can unwrap it and check: if the server returned a structured error with
  an error_code, it's an intentional response that won't change on retry — so skip the retry
  prompt. Only offer retry for truly transient errors (network failures, unstructured 5xx).

Author: seperman

internal/apierror/http.go

@@ -31,12 +31,7 @@ func HandleHTTPErrorFromBytes(statusCode int, body []byte, contextMsg string) er
 		)
 	}
 
-	// Format user-friendly message
-	message := opError.Format()
-	if contextMsg != "" {
-		message = fmt.Sprintf("%s: %s", contextMsg, message)
-	}
-
-	// Map to appropriate exit code
-	return errors.FromHTTPStatus(statusCode, message)
+	// Wrap the OperationalError as the cause so callers can unwrap it
+	// to inspect error codes, severity, etc.
+	return errors.FromHTTPStatusWithCause(statusCode, opError, contextMsg)
 }

internal/apierror/parser.go

@@ -170,6 +170,11 @@ func formatField(loc []interface{}) string {
 	return strings.Join(parts, ".")
 }
 
+// Error implements the error interface so OperationalError can be wrapped in error chains.
+func (e *OperationalError) Error() string {
+	return e.Format()
+}
+
 // Format returns a user-friendly error message
 func (e *OperationalError) Format() string {
 	var parts []string

internal/commands/auth/login.go

@@ -2,16 +2,17 @@ package auth
 
 import (
 	"context"
+	"errors"
 	"fmt"
 	"os"
 	"strings"
 	"time"
 
+	"github.com/qlustered/qctl/internal/apierror"
 	"github.com/qlustered/qctl/internal/auth"
 	"github.com/qlustered/qctl/internal/auth/oauth"
 	"github.com/qlustered/qctl/internal/cmdutil"
 	"github.com/qlustered/qctl/internal/config"
-	"github.com/qlustered/qctl/internal/errors"
 	"github.com/spf13/cobra"
 )
 
@@ -252,13 +253,14 @@ func exchangeWithRetry(ctx context.Context, authClient *auth.Client, kindeAccess
 }
 
 // isRetryable returns true for transient errors worth retrying (network failures,
-// server 5xx). Returns false for permanent client errors (4xx) like account setup
-// issues, auth failures, or bad requests.
+// generic server errors). Returns false when the server returned a structured error
+// with an error code — those are intentional responses that won't change on retry.
 func isRetryable(err error) bool {
-	exitCode := errors.GetExitCode(err)
-	// ExitGenericError (1) covers 5xx and untyped errors (e.g. network failures).
-	// All other exit codes (bad usage, not found, unauthorized) are permanent.
-	return exitCode == errors.ExitGenericError
+	var opErr *apierror.OperationalError
+	if errors.As(err, &opErr) && opErr.ErrorCode != "" {
+		return false
+	}
+	return true
 }
 
 // promptRetry asks the user if they want to retry the operation

internal/errors/errors.go

@@ -103,6 +103,23 @@ func FromHTTPStatus(statusCode int, message string) *Error {
 	}
 }
 
+// FromHTTPStatusWithCause maps an HTTP status code to an appropriate exit code,
+// wrapping the given cause error so it can be unwrapped later.
+func FromHTTPStatusWithCause(statusCode int, cause error, contextMsg string) *Error {
+	switch {
+	case statusCode == http.StatusNotFound:
+		return Wrap(ExitNotFound, cause, contextMsg)
+	case statusCode == http.StatusUnauthorized || statusCode == http.StatusForbidden:
+		return Wrap(ExitUnauthorized, cause, contextMsg)
+	case statusCode >= 500:
+		return Wrap(ExitGenericError, cause, contextMsg)
+	case statusCode >= 400:
+		return Wrap(ExitBadUsage, cause, contextMsg)
+	default:
+		return Wrap(ExitGenericError, cause, contextMsg)
+	}
+}
+
 // GetExitCode extracts the exit code from an error
 // Returns ExitGenericError (1) if the error is not an *Error
 func GetExitCode(err error) int {