cloudposse
diff --git a/‎NOTICE‎
Lines changed: 7 additions & 7 deletions b/‎NOTICE‎
Lines changed: 7 additions & 7 deletions
diff --git a/‎cmd/auth_console.go‎
Lines changed: 2 additions & 2 deletions b/‎cmd/auth_console.go‎
Lines changed: 2 additions & 2 deletions
diff --git a/‎cmd/auth_console_test.go‎
Lines changed: 34 additions & 22 deletions b/‎cmd/auth_console_test.go‎
Lines changed: 34 additions & 22 deletions
diff --git a/‎cmd/auth_env.go‎
Lines changed: 1 addition & 1 deletion b/‎cmd/auth_env.go‎
Lines changed: 1 addition & 1 deletion
diff --git a/‎cmd/auth_exec.go‎
Lines changed: 8 additions & 8 deletions b/‎cmd/auth_exec.go‎
Lines changed: 8 additions & 8 deletions
diff --git a/‎cmd/auth_list.go‎
Lines changed: 4 additions & 5 deletions b/‎cmd/auth_list.go‎
Lines changed: 4 additions & 5 deletions
@@ -107,19 +107,19 @@ APACHE 2.0 LICENSED DEPENDENCIES
 
   - github.com/aws/aws-sdk-go-v2/config
     License: Apache-2.0
-    URL: https://github.com/aws/aws-sdk-go-v2/blob/config/v1.32.0/config/LICENSE.txt
+    URL: https://github.com/aws/aws-sdk-go-v2/blob/config/v1.32.1/config/LICENSE.txt
 
   - github.com/aws/aws-sdk-go-v2/credentials
     License: Apache-2.0
-    URL: https://github.com/aws/aws-sdk-go-v2/blob/credentials/v1.19.0/credentials/LICENSE.txt
+    URL: https://github.com/aws/aws-sdk-go-v2/blob/credentials/v1.19.1/credentials/LICENSE.txt
 
   - github.com/aws/aws-sdk-go-v2/feature/ec2/imds
     License: Apache-2.0
     URL: https://github.com/aws/aws-sdk-go-v2/blob/feature/ec2/imds/v1.18.14/feature/ec2/imds/LICENSE.txt
 
   - github.com/aws/aws-sdk-go-v2/feature/s3/manager
     License: Apache-2.0
-    URL: https://github.com/aws/aws-sdk-go-v2/blob/feature/s3/manager/v1.20.9/feature/s3/manager/LICENSE.txt
+    URL: https://github.com/aws/aws-sdk-go-v2/blob/feature/s3/manager/v1.20.11/feature/s3/manager/LICENSE.txt
 
   - github.com/aws/aws-sdk-go-v2/internal/configsources
     License: Apache-2.0
@@ -155,7 +155,7 @@ APACHE 2.0 LICENSED DEPENDENCIES
 
   - github.com/aws/aws-sdk-go-v2/service/s3
     License: Apache-2.0
-    URL: https://github.com/aws/aws-sdk-go-v2/blob/service/s3/v1.91.1/service/s3/LICENSE.txt
+    URL: https://github.com/aws/aws-sdk-go-v2/blob/service/s3/v1.92.0/service/s3/LICENSE.txt
 
   - github.com/aws/aws-sdk-go-v2/service/secretsmanager
     License: Apache-2.0
@@ -175,7 +175,7 @@ APACHE 2.0 LICENSED DEPENDENCIES
 
   - github.com/aws/aws-sdk-go-v2/service/ssooidc
     License: Apache-2.0
-    URL: https://github.com/aws/aws-sdk-go-v2/blob/service/ssooidc/v1.35.8/service/ssooidc/LICENSE.txt
+    URL: https://github.com/aws/aws-sdk-go-v2/blob/service/ssooidc/v1.35.9/service/ssooidc/LICENSE.txt
 
   - github.com/aws/aws-sdk-go-v2/service/sts
     License: Apache-2.0
@@ -1214,7 +1214,7 @@ MIT LICENSED DEPENDENCIES
 
   - github.com/gabriel-vasile/mimetype
     License: MIT
-    URL: https://github.com/gabriel-vasile/mimetype/blob/v1.4.10/LICENSE
+    URL: https://github.com/gabriel-vasile/mimetype/blob/v1.4.11/LICENSE
 
   - github.com/getsentry/sentry-go
     License: MIT
@@ -1490,7 +1490,7 @@ MIT LICENSED DEPENDENCIES
 
   - github.com/posthog/posthog-go
     License: MIT
-    URL: https://github.com/posthog/posthog-go/blob/v1.6.12/LICENSE.md
+    URL: https://github.com/posthog/posthog-go/blob/v1.6.13/LICENSE.md
 
   - github.com/rivo/uniseg
     License: MIT
 
@@ -101,13 +101,13 @@ func executeAuthConsoleCommand(cmd *cobra.Command, args []string) error {
 	// Check if provider supports console access and get the console URL generator.
 	consoleProvider, err := getConsoleProvider(authManager, whoami.Identity)
 	if err != nil {
-		return fmt.Errorf("%w: %w", errUtils.ErrAuthConsole, err)
+		return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrAuthConsole, err)
 	}
 
 	// Resolve session duration (flag takes precedence over provider config).
 	sessionDuration, err := resolveConsoleDuration(cmd, authManager, whoami.Provider)
 	if err != nil {
-		return fmt.Errorf("%w: %w", errUtils.ErrAuthConsole, err)
+		return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrAuthConsole, err)
 	}
 
 	// Generate console URL.
 
@@ -581,6 +581,8 @@ func TestResolveIdentityName(t *testing.T) {
 }
 
 // mockAuthManagerForProvider implements minimal AuthManager for testing getConsoleProvider.
+// Only GetProviderKindForIdentity is implemented - other methods return ErrNotImplemented
+// because they are not needed by TestGetConsoleProvider.
 type mockAuthManagerForProvider struct {
 	providerKind string
 }
@@ -590,27 +592,27 @@ func (m *mockAuthManagerForProvider) GetProviderKindForIdentity(identityName str
 }
 
 func (m *mockAuthManagerForProvider) GetCachedCredentials(ctx context.Context, identityName string) (*types.WhoamiInfo, error) {
-	return nil, errors.New("not implemented")
+	return nil, errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForProvider) Authenticate(ctx context.Context, identityName string) (*types.WhoamiInfo, error) {
-	return nil, errors.New("not implemented")
+	return nil, errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForProvider) GetDefaultIdentity(_ bool) (string, error) {
-	return "", errors.New("not implemented")
+	return "", errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForProvider) ListIdentities() []string {
 	return nil
 }
 
 func (m *mockAuthManagerForProvider) Logout(ctx context.Context, identityName string, deleteKeychain bool) error {
-	return errors.New("not implemented")
+	return errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForProvider) GetIdentity(identityName string) (types.Identity, error) {
-	return nil, errors.New("not implemented")
+	return nil, errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForProvider) GetFilesDisplayPath(providerName string) string {
@@ -626,11 +628,11 @@ func (m *mockAuthManagerForProvider) GetIdentities() map[string]schema.Identity
 }
 
 func (m *mockAuthManagerForProvider) Whoami(ctx context.Context, identityName string) (*types.WhoamiInfo, error) {
-	return nil, errors.New("not implemented")
+	return nil, errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForProvider) Validate() error {
-	return errors.New("not implemented")
+	return errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForProvider) GetProviderForIdentity(identityName string) string {
@@ -650,37 +652,43 @@ func (m *mockAuthManagerForProvider) GetProviders() map[string]schema.Provider {
 }
 
 func (m *mockAuthManagerForProvider) LogoutProvider(ctx context.Context, providerName string, deleteKeychain bool) error {
-	return errors.New("not implemented")
+	return errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForProvider) LogoutAll(ctx context.Context, deleteKeychain bool) error {
-	return errors.New("not implemented")
+	return errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForProvider) GetEnvironmentVariables(identityName string) (map[string]string, error) {
-	return nil, errors.New("not implemented")
+	return nil, errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForProvider) PrepareShellEnvironment(ctx context.Context, identityName string, currentEnv []string) ([]string, error) {
-	return nil, errors.New("not implemented")
+	return nil, errUtils.ErrNotImplemented
+}
+
+func (m *mockAuthManagerForProvider) AuthenticateProvider(ctx context.Context, providerName string) (*types.WhoamiInfo, error) {
+	return nil, errUtils.ErrNotImplemented
 }
 
 // mockAuthManagerForIdentity implements minimal AuthManager for testing resolveIdentityName.
+// Only GetDefaultIdentity is implemented - other methods return ErrNotImplemented
+// because they are not needed by TestResolveIdentityName.
 type mockAuthManagerForIdentity struct {
 	defaultIdentity string
 	defaultErr      error
 }
 
 func (m *mockAuthManagerForIdentity) GetProviderKindForIdentity(identityName string) (string, error) {
-	return "", errors.New("not implemented")
+	return "", errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForIdentity) GetCachedCredentials(ctx context.Context, identityName string) (*types.WhoamiInfo, error) {
-	return nil, errors.New("not implemented")
+	return nil, errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForIdentity) Authenticate(ctx context.Context, identityName string) (*types.WhoamiInfo, error) {
-	return nil, errors.New("not implemented")
+	return nil, errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForIdentity) GetDefaultIdentity(_ bool) (string, error) {
@@ -695,11 +703,11 @@ func (m *mockAuthManagerForIdentity) ListIdentities() []string {
 }
 
 func (m *mockAuthManagerForIdentity) Logout(ctx context.Context, identityName string, deleteKeychain bool) error {
-	return errors.New("not implemented")
+	return errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForIdentity) GetIdentity(identityName string) (types.Identity, error) {
-	return nil, errors.New("not implemented")
+	return nil, errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForIdentity) GetFilesDisplayPath(providerName string) string {
@@ -715,11 +723,11 @@ func (m *mockAuthManagerForIdentity) GetIdentities() map[string]schema.Identity
 }
 
 func (m *mockAuthManagerForIdentity) Whoami(ctx context.Context, identityName string) (*types.WhoamiInfo, error) {
-	return nil, errors.New("not implemented")
+	return nil, errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForIdentity) Validate() error {
-	return errors.New("not implemented")
+	return errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForIdentity) GetProviderForIdentity(identityName string) string {
@@ -739,19 +747,23 @@ func (m *mockAuthManagerForIdentity) GetProviders() map[string]schema.Provider {
 }
 
 func (m *mockAuthManagerForIdentity) LogoutProvider(ctx context.Context, providerName string, deleteKeychain bool) error {
-	return errors.New("not implemented")
+	return errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForIdentity) LogoutAll(ctx context.Context, deleteKeychain bool) error {
-	return errors.New("not implemented")
+	return errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForIdentity) GetEnvironmentVariables(identityName string) (map[string]string, error) {
-	return nil, errors.New("not implemented")
+	return nil, errUtils.ErrNotImplemented
 }
 
 func (m *mockAuthManagerForIdentity) PrepareShellEnvironment(ctx context.Context, identityName string, currentEnv []string) ([]string, error) {
-	return nil, errors.New("not implemented")
+	return nil, errUtils.ErrNotImplemented
+}
+
+func (m *mockAuthManagerForIdentity) AuthenticateProvider(ctx context.Context, providerName string) (*types.WhoamiInfo, error) {
+	return nil, errUtils.ErrNotImplemented
 }
 
 func TestResolveConsoleDuration(t *testing.T) {
 
@@ -81,7 +81,7 @@ var authEnvCmd = &cobra.Command{
 						return errUtils.ErrUserAborted
 					}
 					// Wrap with ErrAuthenticationFailed sentinel while preserving original error.
-					return fmt.Errorf("%w: %w", errUtils.ErrAuthenticationFailed, err)
+					return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrAuthenticationFailed, err)
 				}
 			}
 
 
@@ -48,19 +48,19 @@ func executeAuthExecCommandCore(cmd *cobra.Command, args []string) error {
 
 	// Validate command args before attempting authentication.
 	if len(commandArgs) == 0 {
-		return errors.Join(errUtils.ErrNoCommandSpecified, errUtils.ErrInvalidSubcommand)
+		return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrNoCommandSpecified, errUtils.ErrInvalidSubcommand)
 	}
 
 	// Load atmos configuration (processStacks=false since auth commands don't require stack manifests)
 	atmosConfig, err := cfg.InitCliConfig(schema.ConfigAndStacksInfo{}, false)
 	if err != nil {
-		return errors.Join(errUtils.ErrFailedToInitializeAtmosConfig, err)
+		return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrFailedToInitializeAtmosConfig, err)
 	}
 
 	// Create auth manager
 	authManager, err := createAuthManager(&atmosConfig.Auth)
 	if err != nil {
-		return errors.Join(errUtils.ErrFailedToInitializeAuthManager, err)
+		return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrFailedToInitializeAuthManager, err)
 	}
 
 	// Get identity from extracted flag or use default.
@@ -83,7 +83,7 @@ func executeAuthExecCommandCore(cmd *cobra.Command, args []string) error {
 	if identityName == "" || forceSelect {
 		defaultIdentity, err := authManager.GetDefaultIdentity(forceSelect)
 		if err != nil {
-			return errors.Join(errUtils.ErrNoDefaultIdentity, err)
+			return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrNoDefaultIdentity, err)
 		}
 		identityName = defaultIdentity
 	}
@@ -101,7 +101,7 @@ func executeAuthExecCommandCore(cmd *cobra.Command, args []string) error {
 			if errors.Is(err, errUtils.ErrUserAborted) {
 				return errUtils.ErrUserAborted
 			}
-			return errors.Join(errUtils.ErrAuthenticationFailed, err)
+			return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrAuthenticationFailed, err)
 		}
 	}
 
@@ -129,7 +129,7 @@ func executeAuthExecCommandCore(cmd *cobra.Command, args []string) error {
 // executeCommandWithEnv executes a command with additional environment variables.
 func executeCommandWithEnv(args []string, envVars map[string]string) error {
 	if len(args) == 0 {
-		return errors.Join(errUtils.ErrNoCommandSpecified, errUtils.ErrInvalidSubcommand)
+		return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrNoCommandSpecified, errUtils.ErrInvalidSubcommand)
 	}
 
 	// Prepare the command
@@ -139,7 +139,7 @@ func executeCommandWithEnv(args []string, envVars map[string]string) error {
 	// Look for the command in PATH
 	cmdPath, err := exec.LookPath(cmdName)
 	if err != nil {
-		return errors.Join(errUtils.ErrCommandNotFound, err)
+		return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrCommandNotFound, err)
 	}
 
 	// Prepare environment variables
@@ -165,7 +165,7 @@ func executeCommandWithEnv(args []string, envVars map[string]string) error {
 				return errUtils.ExitCodeError{Code: status.ExitStatus()}
 			}
 		}
-		return errors.Join(errUtils.ErrSubcommandFailed, err)
+		return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrSubcommandFailed, err)
 	}
 
 	return nil
 
@@ -3,7 +3,6 @@ package cmd
 import (
 	_ "embed"
 	"encoding/json"
-	"errors"
 	"fmt"
 	"sort"
 	"strings"
@@ -337,7 +336,7 @@ func renderJSON(providers map[string]schema.Provider, identities map[string]sche
 
 	data, err := json.MarshalIndent(output, "", "  ")
 	if err != nil {
-		return "", errors.Join(errUtils.ErrParseFile, fmt.Errorf("failed to marshal JSON: %w", err))
+		return "", fmt.Errorf("%w: failed to marshal JSON: %w", errUtils.ErrParseFile, err)
 	}
 
 	return string(data) + "\n", nil
@@ -359,7 +358,7 @@ func renderYAML(providers map[string]schema.Provider, identities map[string]sche
 
 	data, err := yaml.Marshal(output)
 	if err != nil {
-		return "", errors.Join(errUtils.ErrParseFile, fmt.Errorf("failed to marshal YAML: %w", err))
+		return "", fmt.Errorf("%w: failed to marshal YAML: %w", errUtils.ErrParseFile, err)
 	}
 
 	return string(data), nil
@@ -371,12 +370,12 @@ func loadAuthManagerForList() (authTypes.AuthManager, error) {
 
 	atmosConfig, err := cfg.InitCliConfig(schema.ConfigAndStacksInfo{}, false)
 	if err != nil {
-		return nil, errors.Join(errUtils.ErrInvalidAuthConfig, fmt.Errorf("failed to load atmos config: %w", err))
+		return nil, fmt.Errorf("%w: failed to load atmos config: %w", errUtils.ErrInvalidAuthConfig, err)
 	}
 
 	manager, err := createAuthManager(&atmosConfig.Auth)
 	if err != nil {
-		return nil, errors.Join(errUtils.ErrInvalidAuthConfig, fmt.Errorf("failed to create auth manager: %w", err))
+		return nil, fmt.Errorf("%w: failed to create auth manager: %w", errUtils.ErrInvalidAuthConfig, err)
 	}
 
 	return manager, nil
Original file line number	Diff line number	Diff line change
`@@ -101,13 +101,13 @@ func executeAuthConsoleCommand(cmd *cobra.Command, args []string) error {`
`101`	`101`	`// Check if provider supports console access and get the console URL generator.`
`102`	`102`	`consoleProvider, err := getConsoleProvider(authManager, whoami.Identity)`
`103`	`103`	`if err != nil {`
`104`		`- return fmt.Errorf("%w: %w", errUtils.ErrAuthConsole, err)`
	`104`	`+ return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrAuthConsole, err)`
`105`	`105`	`}`
`106`	`106`
`107`	`107`	`// Resolve session duration (flag takes precedence over provider config).`
`108`	`108`	`sessionDuration, err := resolveConsoleDuration(cmd, authManager, whoami.Provider)`
`109`	`109`	`if err != nil {`
`110`		`- return fmt.Errorf("%w: %w", errUtils.ErrAuthConsole, err)`
	`110`	`+ return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrAuthConsole, err)`
`111`	`111`	`}`
`112`	`112`
`113`	`113`	`// Generate console URL.`
Original file line number	Diff line number	Diff line change
`@@ -581,6 +581,8 @@ func TestResolveIdentityName(t *testing.T) {`
`581`	`581`	`}`
`582`	`582`
`583`	`583`	`// mockAuthManagerForProvider implements minimal AuthManager for testing getConsoleProvider.`
	`584`	`+// Only GetProviderKindForIdentity is implemented - other methods return ErrNotImplemented`
	`585`	`+// because they are not needed by TestGetConsoleProvider.`
`584`	`586`	`type mockAuthManagerForProvider struct {`
`585`	`587`	`providerKind string`
`586`	`588`	`}`
`@@ -590,27 +592,27 @@ func (m *mockAuthManagerForProvider) GetProviderKindForIdentity(identityName str`
`590`	`592`	`}`
`591`	`593`
`592`	`594`	`func (m mockAuthManagerForProvider) GetCachedCredentials(ctx context.Context, identityName string) (types.WhoamiInfo, error) {`
`593`		`- return nil, errors.New("not implemented")`
	`595`	`+ return nil, errUtils.ErrNotImplemented`
`594`	`596`	`}`
`595`	`597`
`596`	`598`	`func (m mockAuthManagerForProvider) Authenticate(ctx context.Context, identityName string) (types.WhoamiInfo, error) {`
`597`		`- return nil, errors.New("not implemented")`
	`599`	`+ return nil, errUtils.ErrNotImplemented`
`598`	`600`	`}`
`599`	`601`
`600`	`602`	`func (m *mockAuthManagerForProvider) GetDefaultIdentity(_ bool) (string, error) {`
`601`		`- return "", errors.New("not implemented")`
	`603`	`+ return "", errUtils.ErrNotImplemented`
`602`	`604`	`}`
`603`	`605`
`604`	`606`	`func (m *mockAuthManagerForProvider) ListIdentities() []string {`
`605`	`607`	`return nil`
`606`	`608`	`}`
`607`	`609`
`608`	`610`	`func (m *mockAuthManagerForProvider) Logout(ctx context.Context, identityName string, deleteKeychain bool) error {`
`609`		`- return errors.New("not implemented")`
	`611`	`+ return errUtils.ErrNotImplemented`
`610`	`612`	`}`
`611`	`613`
`612`	`614`	`func (m *mockAuthManagerForProvider) GetIdentity(identityName string) (types.Identity, error) {`
`613`		`- return nil, errors.New("not implemented")`
	`615`	`+ return nil, errUtils.ErrNotImplemented`
`614`	`616`	`}`
`615`	`617`
`616`	`618`	`func (m *mockAuthManagerForProvider) GetFilesDisplayPath(providerName string) string {`
`@@ -626,11 +628,11 @@ func (m *mockAuthManagerForProvider) GetIdentities() map[string]schema.Identity`
`626`	`628`	`}`
`627`	`629`
`628`	`630`	`func (m mockAuthManagerForProvider) Whoami(ctx context.Context, identityName string) (types.WhoamiInfo, error) {`
`629`		`- return nil, errors.New("not implemented")`
	`631`	`+ return nil, errUtils.ErrNotImplemented`
`630`	`632`	`}`
`631`	`633`
`632`	`634`	`func (m *mockAuthManagerForProvider) Validate() error {`
`633`		`- return errors.New("not implemented")`
	`635`	`+ return errUtils.ErrNotImplemented`
`634`	`636`	`}`
`635`	`637`
`636`	`638`	`func (m *mockAuthManagerForProvider) GetProviderForIdentity(identityName string) string {`
`@@ -650,37 +652,43 @@ func (m *mockAuthManagerForProvider) GetProviders() map[string]schema.Provider {`
`650`	`652`	`}`
`651`	`653`
`652`	`654`	`func (m *mockAuthManagerForProvider) LogoutProvider(ctx context.Context, providerName string, deleteKeychain bool) error {`
`653`		`- return errors.New("not implemented")`
	`655`	`+ return errUtils.ErrNotImplemented`
`654`	`656`	`}`
`655`	`657`
`656`	`658`	`func (m *mockAuthManagerForProvider) LogoutAll(ctx context.Context, deleteKeychain bool) error {`
`657`		`- return errors.New("not implemented")`
	`659`	`+ return errUtils.ErrNotImplemented`
`658`	`660`	`}`
`659`	`661`
`660`	`662`	`func (m *mockAuthManagerForProvider) GetEnvironmentVariables(identityName string) (map[string]string, error) {`
`661`		`- return nil, errors.New("not implemented")`
	`663`	`+ return nil, errUtils.ErrNotImplemented`
`662`	`664`	`}`
`663`	`665`
`664`	`666`	`func (m *mockAuthManagerForProvider) PrepareShellEnvironment(ctx context.Context, identityName string, currentEnv []string) ([]string, error) {`
`665`		`- return nil, errors.New("not implemented")`
	`667`	`+ return nil, errUtils.ErrNotImplemented`
	`668`	`+}`
	`669`	`+`
	`670`	`+func (m mockAuthManagerForProvider) AuthenticateProvider(ctx context.Context, providerName string) (types.WhoamiInfo, error) {`
	`671`	`+ return nil, errUtils.ErrNotImplemented`
`666`	`672`	`}`
`667`	`673`
`668`	`674`	`// mockAuthManagerForIdentity implements minimal AuthManager for testing resolveIdentityName.`
	`675`	`+// Only GetDefaultIdentity is implemented - other methods return ErrNotImplemented`
	`676`	`+// because they are not needed by TestResolveIdentityName.`
`669`	`677`	`type mockAuthManagerForIdentity struct {`
`670`	`678`	`defaultIdentity string`
`671`	`679`	`defaultErr error`
`672`	`680`	`}`
`673`	`681`
`674`	`682`	`func (m *mockAuthManagerForIdentity) GetProviderKindForIdentity(identityName string) (string, error) {`
`675`		`- return "", errors.New("not implemented")`
	`683`	`+ return "", errUtils.ErrNotImplemented`
`676`	`684`	`}`
`677`	`685`
`678`	`686`	`func (m mockAuthManagerForIdentity) GetCachedCredentials(ctx context.Context, identityName string) (types.WhoamiInfo, error) {`
`679`		`- return nil, errors.New("not implemented")`
	`687`	`+ return nil, errUtils.ErrNotImplemented`
`680`	`688`	`}`
`681`	`689`
`682`	`690`	`func (m mockAuthManagerForIdentity) Authenticate(ctx context.Context, identityName string) (types.WhoamiInfo, error) {`
`683`		`- return nil, errors.New("not implemented")`
	`691`	`+ return nil, errUtils.ErrNotImplemented`
`684`	`692`	`}`
`685`	`693`
`686`	`694`	`func (m *mockAuthManagerForIdentity) GetDefaultIdentity(_ bool) (string, error) {`
`@@ -695,11 +703,11 @@ func (m *mockAuthManagerForIdentity) ListIdentities() []string {`
`695`	`703`	`}`
`696`	`704`
`697`	`705`	`func (m *mockAuthManagerForIdentity) Logout(ctx context.Context, identityName string, deleteKeychain bool) error {`
`698`		`- return errors.New("not implemented")`
	`706`	`+ return errUtils.ErrNotImplemented`
`699`	`707`	`}`
`700`	`708`
`701`	`709`	`func (m *mockAuthManagerForIdentity) GetIdentity(identityName string) (types.Identity, error) {`
`702`		`- return nil, errors.New("not implemented")`
	`710`	`+ return nil, errUtils.ErrNotImplemented`
`703`	`711`	`}`
`704`	`712`
`705`	`713`	`func (m *mockAuthManagerForIdentity) GetFilesDisplayPath(providerName string) string {`
`@@ -715,11 +723,11 @@ func (m *mockAuthManagerForIdentity) GetIdentities() map[string]schema.Identity`
`715`	`723`	`}`
`716`	`724`
`717`	`725`	`func (m mockAuthManagerForIdentity) Whoami(ctx context.Context, identityName string) (types.WhoamiInfo, error) {`
`718`		`- return nil, errors.New("not implemented")`
	`726`	`+ return nil, errUtils.ErrNotImplemented`
`719`	`727`	`}`
`720`	`728`
`721`	`729`	`func (m *mockAuthManagerForIdentity) Validate() error {`
`722`		`- return errors.New("not implemented")`
	`730`	`+ return errUtils.ErrNotImplemented`
`723`	`731`	`}`
`724`	`732`
`725`	`733`	`func (m *mockAuthManagerForIdentity) GetProviderForIdentity(identityName string) string {`
`@@ -739,19 +747,23 @@ func (m *mockAuthManagerForIdentity) GetProviders() map[string]schema.Provider {`
`739`	`747`	`}`
`740`	`748`
`741`	`749`	`func (m *mockAuthManagerForIdentity) LogoutProvider(ctx context.Context, providerName string, deleteKeychain bool) error {`
`742`		`- return errors.New("not implemented")`
	`750`	`+ return errUtils.ErrNotImplemented`
`743`	`751`	`}`
`744`	`752`
`745`	`753`	`func (m *mockAuthManagerForIdentity) LogoutAll(ctx context.Context, deleteKeychain bool) error {`
`746`		`- return errors.New("not implemented")`
	`754`	`+ return errUtils.ErrNotImplemented`
`747`	`755`	`}`
`748`	`756`
`749`	`757`	`func (m *mockAuthManagerForIdentity) GetEnvironmentVariables(identityName string) (map[string]string, error) {`
`750`		`- return nil, errors.New("not implemented")`
	`758`	`+ return nil, errUtils.ErrNotImplemented`
`751`	`759`	`}`
`752`	`760`
`753`	`761`	`func (m *mockAuthManagerForIdentity) PrepareShellEnvironment(ctx context.Context, identityName string, currentEnv []string) ([]string, error) {`
`754`		`- return nil, errors.New("not implemented")`
	`762`	`+ return nil, errUtils.ErrNotImplemented`
	`763`	`+}`
	`764`	`+`
	`765`	`+func (m mockAuthManagerForIdentity) AuthenticateProvider(ctx context.Context, providerName string) (types.WhoamiInfo, error) {`
	`766`	`+ return nil, errUtils.ErrNotImplemented`
`755`	`767`	`}`
`756`	`768`
`757`	`769`	`func TestResolveConsoleDuration(t *testing.T) {`
Original file line number	Diff line number	Diff line change
`@@ -81,7 +81,7 @@ var authEnvCmd = &cobra.Command{`
`81`	`81`	`return errUtils.ErrUserAborted`
`82`	`82`	`}`
`83`	`83`	`// Wrap with ErrAuthenticationFailed sentinel while preserving original error.`
`84`		`- return fmt.Errorf("%w: %w", errUtils.ErrAuthenticationFailed, err)`
	`84`	`+ return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrAuthenticationFailed, err)`
`85`	`85`	`}`
`86`	`86`	`}`
`87`	`87`
Original file line number	Diff line number	Diff line change
`@@ -48,19 +48,19 @@ func executeAuthExecCommandCore(cmd *cobra.Command, args []string) error {`
`48`	`48`
`49`	`49`	`// Validate command args before attempting authentication.`
`50`	`50`	`if len(commandArgs) == 0 {`
`51`		`- return errors.Join(errUtils.ErrNoCommandSpecified, errUtils.ErrInvalidSubcommand)`
	`51`	`+ return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrNoCommandSpecified, errUtils.ErrInvalidSubcommand)`
`52`	`52`	`}`
`53`	`53`
`54`	`54`	`// Load atmos configuration (processStacks=false since auth commands don't require stack manifests)`
`55`	`55`	`atmosConfig, err := cfg.InitCliConfig(schema.ConfigAndStacksInfo{}, false)`
`56`	`56`	`if err != nil {`
`57`		`- return errors.Join(errUtils.ErrFailedToInitializeAtmosConfig, err)`
	`57`	`+ return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrFailedToInitializeAtmosConfig, err)`
`58`	`58`	`}`
`59`	`59`
`60`	`60`	`// Create auth manager`
`61`	`61`	`authManager, err := createAuthManager(&atmosConfig.Auth)`
`62`	`62`	`if err != nil {`
`63`		`- return errors.Join(errUtils.ErrFailedToInitializeAuthManager, err)`
	`63`	`+ return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrFailedToInitializeAuthManager, err)`
`64`	`64`	`}`
`65`	`65`
`66`	`66`	`// Get identity from extracted flag or use default.`
`@@ -83,7 +83,7 @@ func executeAuthExecCommandCore(cmd *cobra.Command, args []string) error {`
`83`	`83`	`if identityName == "" \|\| forceSelect {`
`84`	`84`	`defaultIdentity, err := authManager.GetDefaultIdentity(forceSelect)`
`85`	`85`	`if err != nil {`
`86`		`- return errors.Join(errUtils.ErrNoDefaultIdentity, err)`
	`86`	`+ return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrNoDefaultIdentity, err)`
`87`	`87`	`}`
`88`	`88`	`identityName = defaultIdentity`
`89`	`89`	`}`
`@@ -101,7 +101,7 @@ func executeAuthExecCommandCore(cmd *cobra.Command, args []string) error {`
`101`	`101`	`if errors.Is(err, errUtils.ErrUserAborted) {`
`102`	`102`	`return errUtils.ErrUserAborted`
`103`	`103`	`}`
`104`		`- return errors.Join(errUtils.ErrAuthenticationFailed, err)`
	`104`	`+ return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrAuthenticationFailed, err)`
`105`	`105`	`}`
`106`	`106`	`}`
`107`	`107`
`@@ -129,7 +129,7 @@ func executeAuthExecCommandCore(cmd *cobra.Command, args []string) error {`
`129`	`129`	`// executeCommandWithEnv executes a command with additional environment variables.`
`130`	`130`	`func executeCommandWithEnv(args []string, envVars map[string]string) error {`
`131`	`131`	`if len(args) == 0 {`
`132`		`- return errors.Join(errUtils.ErrNoCommandSpecified, errUtils.ErrInvalidSubcommand)`
	`132`	`+ return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrNoCommandSpecified, errUtils.ErrInvalidSubcommand)`
`133`	`133`	`}`
`134`	`134`
`135`	`135`	`// Prepare the command`
`@@ -139,7 +139,7 @@ func executeCommandWithEnv(args []string, envVars map[string]string) error {`
`139`	`139`	`// Look for the command in PATH`
`140`	`140`	`cmdPath, err := exec.LookPath(cmdName)`
`141`	`141`	`if err != nil {`
`142`		`- return errors.Join(errUtils.ErrCommandNotFound, err)`
	`142`	`+ return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrCommandNotFound, err)`
`143`	`143`	`}`
`144`	`144`
`145`	`145`	`// Prepare environment variables`
`@@ -165,7 +165,7 @@ func executeCommandWithEnv(args []string, envVars map[string]string) error {`
`165`	`165`	`return errUtils.ExitCodeError{Code: status.ExitStatus()}`
`166`	`166`	`}`
`167`	`167`	`}`
`168`		`- return errors.Join(errUtils.ErrSubcommandFailed, err)`
	`168`	`+ return fmt.Errorf(errUtils.ErrWrapFormat, errUtils.ErrSubcommandFailed, err)`
`169`	`169`	`}`
`170`	`170`
`171`	`171`	`return nil`