feat!: Replace Vaults with Profiles in config

configs/vui.yaml

@@ -6,15 +6,17 @@ ui:
   theme: "default"
   show_hidden_secrets: false
 
-vaults:
+profiles:
   vault-token:
+    engine: "vault"
     address: "http://localhost:8200"
     auth_method: "token"
     namespace: ""
     auth_config:
       token: "${VAULT_TOKEN}"
 
   vault-ldap:
+    engine: "vault"
     address: "http://localhost:8200"
     auth_method: "ldap"
     namespace: ""
@@ -23,6 +25,7 @@ vaults:
       password: "${LDAP_PASSWORD}"
 
   vault-aws:
+    engine: "vault"
     address: "http://localhost:8200"
     auth_method: "aws"
     namespace: ""
@@ -33,6 +36,7 @@ vaults:
       aws_session_token: "${AWS_SESSION_TOKEN}"
 
   vault-k8s:
+    engine: "vault"
     address: "http://localhost:8200"
     auth_method: "kubernetes"
     namespace: ""
@@ -43,13 +47,15 @@ vaults:
       k8s_ttl: 3600
 
   vault-oidc:
+    engine: "vault"
     address: "http://localhost:8200"
     auth_method: "oidc"
     namespace: ""
     auth_config:
       oidc_role: "vui-oidc-role"
 
   vault-jwt:
+    engine: "vault"
     address: "http://localhost:8200"
     auth_method: "jwt"
     namespace: ""
@@ -58,6 +64,7 @@ vaults:
       jwt: "${JWT}"
 
   vault-userpass:
+    engine: "vault"
     address: "http://localhost:8200"
     auth_method: "userpass"
     namespace: ""
@@ -66,6 +73,7 @@ vaults:
       password: "${USERPASS_PASSWORD}"
 
   vault-cert:
+    engine: "vault"
     address: "https://localhost:8208"
     cert_path: "./sandbox/files/vault.crt"
     auth_method: "cert"
@@ -76,6 +84,7 @@ vaults:
       cert_key_path: "./sandbox/vol/certs/client.key"
 
   vault-azure-todo:
+    engine: "vault"
     address: "http://localhost:8201"
     auth_method: "azure"
     namespace: ""

internal/backend/profiles_interactor.go

@@ -118,12 +118,18 @@ func (i *profileInteractor) ReloadConfiguration() error {
 func (i *profileInteractor) initializeConnections() error {
 	factory := engines.NewEnginesFactory(i.logger)
 
-	for name, profile := range i.config.Vaults {
+	for name, profile := range i.config.Profiles {
 		p := profile
 
-		client, err := factory.SetupEngine("vault", &p) // TODO: add support for other engines
+		// Use the engine from the profile, default to "vault" for backward compatibility
+		engine := p.Engine
+		if engine == "" {
+			engine = "vault"
+		}
+
+		client, err := factory.SetupEngine(engine, &p)
 		if err != nil {
-			i.logger.Warnf("Failed to setup engine for profile '%s': %v", name, err)
+			i.logger.Warnf("Failed to setup engine '%s' for profile '%s': %v", engine, name, err)
 			continue
 		}
 

internal/config/config.go

@@ -11,9 +11,9 @@ import (
 
 // Config represents the application configuration
 type Config struct {
-	App    AppConfig               `mapstructure:"app"`
-	UI     UIConfig                `mapstructure:"ui"`
-	Vaults map[string]VaultProfile `mapstructure:"vaults"`
+	App      AppConfig          `mapstructure:"app"`
+	UI       UIConfig           `mapstructure:"ui"`
+	Profiles map[string]Profile `mapstructure:"profiles"`
 }
 
 // AppConfig contains general application settings
@@ -28,8 +28,9 @@ type UIConfig struct {
 	ShowHiddenSecrets bool   `mapstructure:"show_hidden_secrets"`
 }
 
-// VaultProfile represents a vault connection profile
-type VaultProfile struct {
+// Profile represents a connection profile
+type Profile struct {
+	Engine     string     `mapstructure:"engine"`
 	Address    string     `mapstructure:"address"`
 	CertPath   string     `mapstructure:"cert_path,omitempty"`
 	AuthMethod string     `mapstructure:"auth_method"`
@@ -138,11 +139,12 @@ func setDefaults() {
 	viper.SetDefault("ui.theme", "default")
 	viper.SetDefault("ui.show_hidden_secrets", false)
 
-	// Vaults defaults
-	viper.SetDefault("vaults.local.address", "http://localhost:8200")
-	viper.SetDefault("vaults.local.auth_method", "token")
-	viper.SetDefault("vaults.local.namespace", "")
-	viper.SetDefault("vaults.local.auth_config.token", "${VAULT_TOKEN}")
+	// Profiles defaults
+	viper.SetDefault("profiles.local.engine", "vault")
+	viper.SetDefault("profiles.local.address", "http://localhost:8200")
+	viper.SetDefault("profiles.local.auth_method", "token")
+	viper.SetDefault("profiles.local.namespace", "")
+	viper.SetDefault("profiles.local.auth_config.token", "${VAULT_TOKEN}")
 }
 
 // Save saves the configuration to a file
@@ -157,7 +159,7 @@ func (c *Config) Save() error {
 	// Convert config back to viper format for saving
 	viper.Set("app", c.App)
 	viper.Set("ui", c.UI)
-	viper.Set("vaults", c.Vaults)
+	viper.Set("profiles", c.Profiles)
 
 	return viper.WriteConfigAs(configFile)
 }

internal/config/config_test.go

@@ -17,17 +17,19 @@ func TestLoad(t *testing.T) {
 	assert.Equal(t, "info", config.App.LogLevel)
 	assert.Equal(t, false, config.UI.ShowHiddenSecrets)
 	assert.Equal(t, "default", config.UI.Theme)
-	assert.Equal(t, "http://localhost:8200", config.Vaults["local"].Address)
-	assert.Equal(t, "token", config.Vaults["local"].AuthMethod)
+	assert.Equal(t, "http://localhost:8200", config.Profiles["local"].Address)
+	assert.Equal(t, "token", config.Profiles["local"].AuthMethod)
+	assert.Equal(t, "vault", config.Profiles["local"].Engine)
 }
 
 func TestConfigSave(t *testing.T) {
 	config := &Config{
 		UI: UIConfig{
 			Theme: "light",
 		},
-		Vaults: map[string]VaultProfile{
+		Profiles: map[string]Profile{
 			"default": {
+				Engine:     "vault",
 				Address:    "https://test.vault.com",
 				AuthMethod: "token",
 			},

internal/engines/engines_factory.go

@@ -18,7 +18,7 @@ func NewEnginesFactory(logger *logrus.Logger) *EnginesFactory {
 	}
 }
 
-func (f *EnginesFactory) SetupEngine(name string, profile *config.VaultProfile) (SecretEngine, error) {
+func (f *EnginesFactory) SetupEngine(name string, profile *config.Profile) (SecretEngine, error) {
 	switch name {
 	case "vault":
 		return vault.NewVaultClient(f.logger, profile)

internal/engines/engines_factory_test.go

@@ -14,7 +14,8 @@ func TestEnginesFactory_SetupEngine(t *testing.T) {
 	assert.NotNil(t, factory)
 
 	t.Run("vault", func(t *testing.T) {
-		engine, err := factory.SetupEngine("vault", &config.VaultProfile{
+		engine, err := factory.SetupEngine("vault", &config.Profile{
+			Engine:     "vault",
 			Address:    "http://localhost:8200",
 			AuthMethod: "token",
 		})
@@ -23,7 +24,8 @@ func TestEnginesFactory_SetupEngine(t *testing.T) {
 	})
 
 	t.Run("unknown", func(t *testing.T) {
-		engine, err := factory.SetupEngine("unknown", &config.VaultProfile{
+		engine, err := factory.SetupEngine("unknown", &config.Profile{
+			Engine:  "unknown",
 			Address: "http://localhost:8200",
 		})
 		assert.Error(t, err)

internal/engines/vault/auth/aws.go

@@ -11,7 +11,7 @@ import (
 )
 
 // authenticateWithAWS authenticates using AWS
-func (am *AuthManager) authenticateWithAWS(client *api.Client, profile *config.VaultProfile) error {
+func (am *AuthManager) authenticateWithAWS(client *api.Client, profile *config.Profile) error {
 	accessKeyID := profile.AuthConfig.AWSAccessKeyID
 	if accessKeyID == "" {
 		return fmt.Errorf("aws_access_key_id is required for AWS authentication")

internal/engines/vault/auth/azure.go

@@ -10,7 +10,7 @@ import (
 )
 
 // authenticateWithAzure authenticates using Azure
-func (am *AuthManager) authenticateWithAzure(client *api.Client, profile *config.VaultProfile) error {
+func (am *AuthManager) authenticateWithAzure(client *api.Client, profile *config.Profile) error {
 	role := profile.AuthConfig.AzureRole
 	if role == "" {
 		return fmt.Errorf("azure_role is required for Azure authentication")

internal/engines/vault/auth/cert.go

@@ -8,7 +8,7 @@ import (
 )
 
 // authenticateWithCert authenticates using certificates
-func (am *AuthManager) authenticateWithCert(client *api.Client, profile *config.VaultProfile) error {
+func (am *AuthManager) authenticateWithCert(client *api.Client, profile *config.Profile) error {
 	certName := profile.AuthConfig.CertName
 	if certName == "" {
 		return fmt.Errorf("cert_name is required for cert authentication")

internal/engines/vault/auth/gcp.go

@@ -9,7 +9,7 @@ import (
 )
 
 // authenticateWithGCP authenticates using GCP
-func (am *AuthManager) authenticateWithGCP(client *api.Client, profile *config.VaultProfile) error {
+func (am *AuthManager) authenticateWithGCP(client *api.Client, profile *config.Profile) error {
 	role := profile.AuthConfig.GCPRole
 	if role == "" {
 		return fmt.Errorf("gcp_role is required for GCP authentication")
@@ -45,7 +45,7 @@ func (am *AuthManager) authenticateWithGCP(client *api.Client, profile *config.V
 }
 
 // getGCPCredentials gets GCP credentials from various sources
-func (am *AuthManager) getGCPCredentials(profile *config.VaultProfile) (string, error) {
+func (am *AuthManager) getGCPCredentials(profile *config.Profile) (string, error) {
 	// Check if credentials are provided directly
 	if credentials := profile.AuthConfig.GCPCredentials; credentials != "" {
 		return credentials, nil

internal/engines/vault/auth/jwt.go

@@ -8,7 +8,7 @@ import (
 )
 
 // authenticateWithJWT authenticates using JWT
-func (am *AuthManager) authenticateWithJWT(client *api.Client, profile *config.VaultProfile) error {
+func (am *AuthManager) authenticateWithJWT(client *api.Client, profile *config.Profile) error {
 	role := profile.AuthConfig.JWTRole
 	if role == "" {
 		return fmt.Errorf("jwt_role is required for JWT authentication")

internal/engines/vault/auth/kubernetes.go

@@ -17,7 +17,7 @@ import (
 )
 
 // authenticateWithKubernetes authenticates using Kubernetes
-func (am *AuthManager) authenticateWithKubernetes(client *api.Client, profile *config.VaultProfile) error {
+func (am *AuthManager) authenticateWithKubernetes(client *api.Client, profile *config.Profile) error {
 	role := profile.AuthConfig.K8sRole
 	if role == "" {
 		return fmt.Errorf("k8s_role is required for Kubernetes authentication")
@@ -58,7 +58,7 @@ func (am *AuthManager) authenticateWithKubernetes(client *api.Client, profile *c
 }
 
 // getKubernetesToken gets Kubernetes service account token
-func (am *AuthManager) getKubernetesToken(profile *config.VaultProfile) (string, error) {
+func (am *AuthManager) getKubernetesToken(profile *config.Profile) (string, error) {
 	homeDir, _ := os.UserHomeDir()
 
 	var (

internal/engines/vault/auth/ldap.go

@@ -8,7 +8,7 @@ import (
 )
 
 // authenticateWithLDAP authenticates using LDAP
-func (am *AuthManager) authenticateWithLDAP(client *api.Client, profile *config.VaultProfile) error {
+func (am *AuthManager) authenticateWithLDAP(client *api.Client, profile *config.Profile) error {
 	username := profile.AuthConfig.Username
 	if username == "" {
 		return fmt.Errorf("username is required for LDAP authentication")

internal/engines/vault/auth/manager.go

@@ -37,7 +37,7 @@ func (am *AuthManager) VerifyAuthentication(client *api.Client) error {
 }
 
 // Authenticate authenticates a client using the specified profile
-func (am *AuthManager) Authenticate(client *api.Client, profile *config.VaultProfile) error {
+func (am *AuthManager) Authenticate(client *api.Client, profile *config.Profile) error {
 	switch profile.AuthMethod {
 	case "token":
 		return am.authenticateWithToken(client, profile)

internal/engines/vault/auth/oidc.go

@@ -15,7 +15,7 @@ import (
 	"github.com/rvolykh/vui/internal/config"
 )
 
-func (am *AuthManager) authenticateWithOIDC(client *api.Client, profile *config.VaultProfile) error {
+func (am *AuthManager) authenticateWithOIDC(client *api.Client, profile *config.Profile) error {
 	role := profile.AuthConfig.OIDCRole
 	if role == "" {
 		return fmt.Errorf("oidc_role is required for OIDC authentication")

internal/engines/vault/auth/token.go

@@ -8,7 +8,7 @@ import (
 )
 
 // authenticateWithToken authenticates using a token
-func (am *AuthManager) authenticateWithToken(client *api.Client, profile *config.VaultProfile) error {
+func (am *AuthManager) authenticateWithToken(client *api.Client, profile *config.Profile) error {
 	token := profile.AuthConfig.Token
 	if token == "" {
 		return fmt.Errorf("token is required for token authentication")

internal/engines/vault/auth/userpass.go

@@ -8,7 +8,7 @@ import (
 )
 
 // authenticateWithUserpass authenticates using userpass
-func (am *AuthManager) authenticateWithUserpass(client *api.Client, profile *config.VaultProfile) error {
+func (am *AuthManager) authenticateWithUserpass(client *api.Client, profile *config.Profile) error {
 	username := profile.AuthConfig.Username
 	if username == "" {
 		return fmt.Errorf("username is required for userpass authentication")

internal/engines/vault/vault_client.go

@@ -17,11 +17,11 @@ import (
 
 type VaultClient struct {
 	apiClient *api.Client
-	profile   *config.VaultProfile
+	profile   *config.Profile
 	logger    *logrus.Logger
 }
 
-func NewVaultClient(logger *logrus.Logger, profile *config.VaultProfile) (*VaultClient, error) {
+func NewVaultClient(logger *logrus.Logger, profile *config.Profile) (*VaultClient, error) {
 	apiConfig := api.DefaultConfig()
 	apiConfig.Address = profile.Address
 

internal/engines/vault/vault_client_test.go

@@ -14,7 +14,8 @@ func TestVaultClient(t *testing.T) {
 	logger := logrus.New()
 	logger.SetLevel(logrus.ErrorLevel)
 
-	profile := &config.VaultProfile{
+	profile := &config.Profile{
+		Engine:  "vault",
 		Address: "http://localhost:8200",
 	}
 

internal/ui/app.go

@@ -207,12 +207,12 @@ func (a *App) refresh() {
 	a.layout.Refresh()
 }
 
-// switchVault shows the vault profiles screen for switching vaults
+// switchVault shows the profiles screen for switching profiles
 func (a *App) switchVault() {
 	a.showVaultProfiles()
 }
 
-// showVaultProfiles shows the vault profiles screen
+// showVaultProfiles shows the profiles screen
 func (a *App) showVaultProfiles() {
 	// Mark that we're on the profiles screen
 	a.onProfilesScreen = true

internal/ui/app_test.go

@@ -13,8 +13,9 @@ func TestNewApp(t *testing.T) {
 	// Create test configuration
 	cfg := &config.Config{
 		App: config.AppConfig{},
-		Vaults: map[string]config.VaultProfile{
+		Profiles: map[string]config.Profile{
 			"test": {
+				Engine:     "vault",
 				Address:    "http://localhost:8200",
 				AuthMethod: "token",
 			},

internal/ui/layout_test.go

@@ -12,8 +12,9 @@ import (
 func TestLayoutOfflineMode(t *testing.T) {
 	// Create test configuration
 	cfg := &config.Config{
-		Vaults: map[string]config.VaultProfile{
+		Profiles: map[string]config.Profile{
 			"default": {
+				Engine:     "vault",
 				Address:    "http://localhost:8200",
 				AuthMethod: "token",
 			},
@@ -41,8 +42,9 @@ func TestLayoutOfflineMode(t *testing.T) {
 func TestLayoutStructure(t *testing.T) {
 	// Test that the layout structure is correct
 	cfg := &config.Config{
-		Vaults: map[string]config.VaultProfile{
+		Profiles: map[string]config.Profile{
 			"default": {
+				Engine:     "vault",
 				Address:    "http://localhost:8200",
 				AuthMethod: "token",
 			},