refactor(context): use constants for context keys

This change introduces constants for all context keys used within the application.
Previously, string literals were used directly, which is error-prone and makes
it difficult to manage and update these keys. By centralizing these keys as
constants, I improve code maintainability and reduce the risk of typos or
inconsistent key usage across different parts of the codebase, particularly
in the authentication middleware and request logging.

Author: chew-z

auth.go

@@ -51,7 +51,7 @@ func (a *AuthMiddleware) HTTPContextFunc(next func(ctx context.Context, r *http.
 		if !strings.HasPrefix(authHeader, "Bearer ") {
 			a.logger.Warn("Missing or invalid authorization header from %s", r.RemoteAddr)
 			// Set authentication error in context instead of failing the request
-			ctx = context.WithValue(ctx, "auth_error", "missing_token")
+			ctx = context.WithValue(ctx, authErrorKey, "missing_token")
 			return next(ctx, r)
 		}
 
@@ -61,24 +61,24 @@ func (a *AuthMiddleware) HTTPContextFunc(next func(ctx context.Context, r *http.
 		claims, err := a.validateJWT(token)
 		if err != nil {
 			a.logger.Warn("Invalid token from %s: %v", r.RemoteAddr, err)
-			ctx = context.WithValue(ctx, "auth_error", "invalid_token")
+			ctx = context.WithValue(ctx, authErrorKey, "invalid_token")
 			return next(ctx, r)
 		}
 
 		// Check if token is expired
 		if time.Now().Unix() > claims.ExpiresAt {
 			a.logger.Warn("Expired token from %s", r.RemoteAddr)
-			ctx = context.WithValue(ctx, "auth_error", "expired_token")
+			ctx = context.WithValue(ctx, authErrorKey, "expired_token")
 			return next(ctx, r)
 		}
 
 		a.logger.Info("Authenticated user %s (%s) from %s", claims.Username, claims.Role, r.RemoteAddr)
 
 		// Add user to request context
-		ctx = context.WithValue(ctx, "authenticated", true)
-		ctx = context.WithValue(ctx, "user_id", claims.UserID)
-		ctx = context.WithValue(ctx, "username", claims.Username)
-		ctx = context.WithValue(ctx, "user_role", claims.Role)
+		ctx = context.WithValue(ctx, authenticatedKey, true)
+		ctx = context.WithValue(ctx, userIDKey, claims.UserID)
+		ctx = context.WithValue(ctx, usernameKey, claims.Username)
+		ctx = context.WithValue(ctx, userRoleKey, claims.Role)
 
 		return next(ctx, r)
 	}
@@ -185,25 +185,25 @@ func (a *AuthMiddleware) GenerateToken(userID, username, role string, expiration
 
 // isAuthenticated checks if the request context contains valid authentication
 func isAuthenticated(ctx context.Context) bool {
-	if auth, ok := ctx.Value("authenticated").(bool); ok && auth {
+	if auth, ok := ctx.Value(authenticatedKey).(bool); ok && auth {
 		return true
 	}
 	return false
 }
 
 // getAuthError returns any authentication error from the context
 func getAuthError(ctx context.Context) string {
-	if err, ok := ctx.Value("auth_error").(string); ok {
+	if err, ok := ctx.Value(authErrorKey).(string); ok {
 		return err
 	}
 	return ""
 }
 
 // getUserInfo extracts user information from the authenticated context
 func getUserInfo(ctx context.Context) (userID, username, role string) {
-	if userID, ok := ctx.Value("user_id").(string); ok {
-		if username, ok := ctx.Value("username").(string); ok {
-			if role, ok := ctx.Value("user_role").(string); ok {
+	if userID, ok := ctx.Value(userIDKey).(string); ok {
+		if username, ok := ctx.Value(usernameKey).(string); ok {
+			if role, ok := ctx.Value(userRoleKey).(string); ok {
 				return userID, username, role
 			}
 		}

context.go

@@ -9,4 +9,20 @@ const (
 	loggerKey contextKey = "logger"
 	// configKey is the context key for the configuration
 	configKey contextKey = "config"
+	// authErrorKey is the context key for authentication errors
+	authErrorKey contextKey = "auth_error"
+	// authenticatedKey is the context key for authentication status
+	authenticatedKey contextKey = "authenticated"
+	// userIDKey is the context key for user ID
+	userIDKey contextKey = "user_id"
+	// usernameKey is the context key for username
+	usernameKey contextKey = "username"
+	// userRoleKey is the context key for user role
+	userRoleKey contextKey = "user_role"
+	// httpMethodKey is the context key for HTTP method
+	httpMethodKey contextKey = "http_method"
+	// httpPathKey is the context key for HTTP path
+	httpPathKey contextKey = "http_path"
+	// httpRemoteAddrKey is the context key for HTTP remote address
+	httpRemoteAddrKey contextKey = "http_remote_addr"
 )

files.go

@@ -120,7 +120,7 @@ func (fs *FileStore) UploadFile(ctx context.Context, req *FileUploadRequest) (*F
 	// Validate URI before storing
 	if fileInfo.URI == "" {
 		logger.Error("Invalid URI for uploaded file: empty URI")
-		return nil, errors.New("Invalid URI for uploaded file")
+		return nil, errors.New("invalid URI for uploaded file")
 	}
 
 	logger.Debug("Storing file info with URI: %s", fileInfo.URI)

gemini_server.go

@@ -15,7 +15,7 @@ func NewGeminiServer(ctx context.Context, config *Config) (*GeminiServer, error)
 	}
 
 	if config.GeminiAPIKey == "" {
-		return nil, errors.New("Gemini API key is required")
+		return nil, errors.New("gemini API key is required")
 	}
 
 	// Initialize the Gemini client

main.go

@@ -259,9 +259,9 @@ func createHTTPMiddleware(config *Config, logger Logger) server.HTTPContextFunc
 		}
 
 		// Add request info to context
-		ctx = context.WithValue(ctx, "http_method", r.Method)
-		ctx = context.WithValue(ctx, "http_path", r.URL.Path)
-		ctx = context.WithValue(ctx, "http_remote_addr", r.RemoteAddr)
+		ctx = context.WithValue(ctx, httpMethodKey, r.Method)
+		ctx = context.WithValue(ctx, httpPathKey, r.URL.Path)
+		ctx = context.WithValue(ctx, httpRemoteAddrKey, r.RemoteAddr)
 
 		return ctx
 	}
@@ -458,7 +458,7 @@ func wrapHandlerWithLogger(handler server.ToolHandlerFunc, toolName string, logg
 
 		// Check authentication for HTTP requests if enabled
 		// Note: We need to check if this is an HTTP request and if auth is enabled
-		if httpMethod, ok := ctx.Value("http_method").(string); ok && httpMethod != "" {
+		if httpMethod, ok := ctx.Value(httpMethodKey).(string); ok && httpMethod != "" {
 			// This is an HTTP request, check if auth is required
 			// Get config from the context (we'll need to pass it through)
 			if authError := getAuthError(ctx); authError != "" {