refactor: move vault loading into registry

cmd/andcli/main.go

@@ -1,6 +1,7 @@
 package main
 
 import (
+	"context"
 	"fmt"
 	"log"
 	"os"
@@ -13,12 +14,13 @@ import (
 	"github.com/tjblackheart/andcli/v2/internal/input"
 	"github.com/tjblackheart/andcli/v2/internal/model"
 	"github.com/tjblackheart/andcli/v2/internal/vaults"
-	"github.com/tjblackheart/andcli/v2/internal/vaults/aegis"
-	"github.com/tjblackheart/andcli/v2/internal/vaults/andotp"
-	"github.com/tjblackheart/andcli/v2/internal/vaults/keepass"
-	"github.com/tjblackheart/andcli/v2/internal/vaults/protonpass"
-	"github.com/tjblackheart/andcli/v2/internal/vaults/stratum"
-	"github.com/tjblackheart/andcli/v2/internal/vaults/twofas"
+
+	_ "github.com/tjblackheart/andcli/v2/internal/vaults/aegis"
+	_ "github.com/tjblackheart/andcli/v2/internal/vaults/andotp"
+	_ "github.com/tjblackheart/andcli/v2/internal/vaults/keepass"
+	_ "github.com/tjblackheart/andcli/v2/internal/vaults/protonpass"
+	_ "github.com/tjblackheart/andcli/v2/internal/vaults/stratum"
+	_ "github.com/tjblackheart/andcli/v2/internal/vaults/twofas"
 )
 
 func main() {
@@ -70,42 +72,10 @@ func open(cfg *config.Config) (vaults.Vault, error) {
 		return nil, err
 	}
 
-	defer func() {
-		for i := range pw {
-			pw[i] = 0
-		}
-	}()
-
-	done := make(chan struct{})
-
-	var vault vaults.Vault
-	go func() {
-		switch cfg.Type {
-		case vaults.ANDOTP:
-			vault, err = andotp.Open(cfg.File, pw)
-		case vaults.AEGIS:
-			vault, err = aegis.Open(cfg.File, pw)
-		case vaults.TWOFAS:
-			vault, err = twofas.Open(cfg.File, pw)
-		case vaults.STRATUM:
-			vault, err = stratum.Open(cfg.File, pw)
-		case vaults.KEEPASS:
-			vault, err = keepass.Open(cfg.File, pw)
-		case vaults.PROTON:
-			vault, err = protonpass.Open(cfg.File, pw)
-		default:
-			vault, err = nil, fmt.Errorf("vault type %q: not implemented", cfg.Type)
-		}
-		done <- struct{}{}
-	}()
-
-	select {
-	case <-done:
-	case <-time.After(cfg.DecryptionTimeoutD()):
-		return nil, fmt.Errorf("decrypt: operation timed out. wrong type?")
-	}
+	ctx, cancel := context.WithTimeout(context.Background(), cfg.DecryptionTimeoutD())
+	defer cancel()
 
-	return vault, err
+	return vaults.Open(ctx, cfg.File, pw, cfg.Type)
 }
 
 func password(piped bool) ([]byte, error) {

internal/config/config.go

@@ -16,12 +16,12 @@ import (
 
 type (
 	Config struct {
-		File           string      `yaml:"file"`
-		Type           vaults.Type `yaml:"type"`
-		ClipboardCmd   string      `yaml:"clipboard_cmd"`
-		Options        *Opts       `yaml:"options"`
-		Theme          *Theme      `yaml:"theme"`
-		SessionTimeout int         `yaml:"session_timeout"`
+		File           string           `yaml:"file"`
+		Type           vaults.VaultType `yaml:"type"`
+		ClipboardCmd   string           `yaml:"clipboard_cmd"`
+		Options        *Opts            `yaml:"options"`
+		Theme          *Theme           `yaml:"theme"`
+		SessionTimeout int              `yaml:"session_timeout"`
 		//
 		path              string
 		passwordFromStdin bool

internal/config/config_test.go

@@ -235,7 +235,7 @@ theme:
 
 	cfg := &Config{
 		File:           "/new/vault.json",
-		Type:           vaults.Type("2fas"),
+		Type:           vaults.VaultType("2fas"),
 		ClipboardCmd:   "pbcopy",
 		SessionTimeout: 300,
 		Options: &Opts{
@@ -302,7 +302,7 @@ func Test_create(t *testing.T) {
 	// default config
 	want := &Config{
 		File:           abs,
-		Type:           vaults.Type(*vtype),
+		Type:           vaults.VaultType(*vtype),
 		SessionTimeout: 300,
 		ClipboardCmd:   "",
 		Options: &Opts{

internal/config/flags.go

@@ -14,7 +14,7 @@ import (
 var (
 	set               = flag.NewFlagSet("default", flag.ExitOnError)
 	vfile             = set.StringP("file", "f", "", "Path to the encrypted vault (deprecated: Pass the filename directly)")
-	vtype             = set.StringP("type", "t", "", fmt.Sprintf("Vault type (%s)", vaults.StrTypes()))
+	vtype             = set.StringP("type", "t", "", "Vault types")
 	cmd               = set.StringP("clipboard-cmd", "c", "", "A custom clipboard command, including args (xclip, wl-copy, pbcopy etc.)")
 	pwstdin           = set.Bool("passwd-stdin", false, "Read the vault password from stdin. If set, skips the password input.")
 	query             = set.StringP("query", "q", "", "Query the vault directly and skip TUI functionality")
@@ -27,6 +27,7 @@ var (
 // Parses given flags into the existing config.
 func (cfg *Config) parseFlags() error {
 	set.Usage = func() { usage(true) }
+	set.Lookup("type").Usage = fmt.Sprintf("Vault type (%s)", vaults.StrTypes())
 
 	if err := set.Parse(os.Args[1:]); err != nil {
 		log.Printf("%s: %s", buildinfo.AppName, err)
@@ -54,7 +55,7 @@ func (cfg *Config) parseFlags() error {
 	}
 
 	if *vtype != "" {
-		cfg.Type = vaults.Type(*vtype)
+		cfg.Type = vaults.VaultType(*vtype)
 		cfg.dirty = true
 	}
 

internal/vaults/aegis/aegis.go

@@ -58,6 +58,8 @@ type (
 	}
 )
 
+func init() { vaults.Register(vaultType, Open) }
+
 func Open(filename string, pass []byte) (vaults.Vault, error) {
 	var v aegis
 
@@ -88,7 +90,7 @@ func Open(filename string, pass []byte) (vaults.Vault, error) {
 		return nil, fmt.Errorf("%s: %w", vaultType, err)
 	}
 
-	return v, nil
+	return &v, nil
 }
 
 func (v aegis) Entries() []vaults.Entry {

internal/vaults/aegis/aegis_test.go

@@ -25,15 +25,15 @@ func TestOpen(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			v, err := Open(tt.filename, []byte(tt.password))
-		if tt.fails {
-			if err == nil {
-				t.Fatal("Open() expected error, got none")
+			if tt.fails {
+				if err == nil {
+					t.Fatal("Open() expected error, got none")
+				}
+				if tt.wantErr != nil && !errors.Is(err, tt.wantErr) {
+					t.Fatalf("Open() error = %v, want %v", err, tt.wantErr)
+				}
+				return
 			}
-			if tt.wantErr != nil && !errors.Is(err, tt.wantErr) {
-				t.Fatalf("Open() error = %v, want %v", err, tt.wantErr)
-			}
-			return
-		}
 
 			entries := v.Entries()
 			if len(entries) != 1 {

internal/vaults/andotp/andotp.go

@@ -32,13 +32,15 @@ type (
 	}
 )
 
+func init() { vaults.Register(vaultType, Open) }
+
 func Open(filename string, pass []byte) (vaults.Vault, error) {
 	b, err := os.ReadFile(filename)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %w", vaultType, err)
 	}
 
-	v := &andotp{entries: make([]entry, 0)}
+	v := andotp{entries: make([]entry, 0)}
 
 	if v.IsPlain(b) {
 		return nil, vaults.ErrIsPlain
@@ -53,7 +55,7 @@ func Open(filename string, pass []byte) (vaults.Vault, error) {
 		return nil, fmt.Errorf("%s: %w", vaultType, err)
 	}
 
-	return v, nil
+	return &v, nil
 }
 
 func (v andotp) Entries() []vaults.Entry {

internal/vaults/andotp/andotp_test.go

@@ -24,15 +24,15 @@ func TestOpen(t *testing.T) {
 	for _, tt := range tests {
 		t.Run(tt.name, func(t *testing.T) {
 			v, err := Open(tt.filename, []byte(tt.password))
-		if tt.fails {
-			if err == nil {
-				t.Fatal("Open() expected error, got none")
+			if tt.fails {
+				if err == nil {
+					t.Fatal("Open() expected error, got none")
+				}
+				if tt.wantErr != nil && !errors.Is(err, tt.wantErr) {
+					t.Fatalf("Open() error = %v, want %v", err, tt.wantErr)
+				}
+				return
 			}
-			if tt.wantErr != nil && !errors.Is(err, tt.wantErr) {
-				t.Fatalf("Open() error = %v, want %v", err, tt.wantErr)
-			}
-			return
-		}
 
 			entries := v.Entries()
 			if len(entries) != 1 {

internal/vaults/keepass/keepass.go

@@ -18,6 +18,8 @@ var _ vaults.Vault = &keepass{}
 
 type keepass struct{ entries []gokeepasslib.Entry }
 
+func init() { vaults.Register(vaultType, Open) }
+
 func Open(filename string, pass []byte) (vaults.Vault, error) {
 	v := keepass{entries: make([]gokeepasslib.Entry, 0)}
 	db := gokeepasslib.NewDatabase()
@@ -43,7 +45,7 @@ func Open(filename string, pass []byte) (vaults.Vault, error) {
 
 	v.entries = append(v.entries, parseGroups(db.Content.Root.Groups)...)
 
-	return v, nil
+	return &v, nil
 }
 
 func (v keepass) Entries() []vaults.Entry {

internal/vaults/protonpass/protonpass.go

@@ -25,10 +25,10 @@ var (
 )
 
 type (
-	envelope struct{ Vaults map[string]proton }
+	envelope struct{ Vaults map[string]protonvault }
 
 	// protonvault only implements the essentials for reading OTP data.
-	proton struct {
+	protonvault struct {
 		Name, Description string
 		Items             []struct {
 			Data struct {
@@ -43,14 +43,16 @@ type (
 	}
 )
 
+func init() { vaults.Register(vaultType, Open) }
+
 func Open(filename string, pass []byte) (vaults.Vault, error) {
 	b, err := read(filename)
 	if err != nil {
 		return nil, fmt.Errorf("%s: %s", vaultType, err)
 	}
 
-	var e envelope
-	if e.IsPlain(b) {
+	var v envelope
+	if v.IsPlain(b) {
 		return nil, vaults.ErrIsPlain
 	}
 
@@ -64,11 +66,11 @@ func Open(filename string, pass []byte) (vaults.Vault, error) {
 		return nil, fmt.Errorf("%s: %s", vaultType, err)
 	}
 
-	if err := json.Unmarshal(result.Bytes(), &e); err != nil {
+	if err := json.Unmarshal(result.Bytes(), &v); err != nil {
 		return nil, fmt.Errorf("%s: %s", vaultType, err)
 	}
 
-	return e, nil
+	return &v, nil
 }
 
 func (e envelope) Entries() []vaults.Entry {

internal/vaults/registry.go

@@ -0,0 +1,79 @@
+package vaults
+
+import (
+	"context"
+	"fmt"
+	"slices"
+	"strings"
+)
+
+const (
+	ANDOTP  VaultType = "andotp"
+	AEGIS   VaultType = "aegis"
+	TWOFAS  VaultType = "twofas"
+	STRATUM VaultType = "stratum"
+	KEEPASS VaultType = "keepass"
+	PROTON  VaultType = "proton"
+)
+
+type (
+	OpenFn    func(path string, pass []byte) (Vault, error)
+	VaultType string
+)
+
+func (vt VaultType) String() string { return string(vt) }
+
+var registry = make(map[VaultType]OpenFn)
+
+// Register registers a vault type with the given open function.
+func Register(vt VaultType, fn OpenFn) { registry[vt] = fn }
+
+// Open opens a vault of the given type at the given path using the given password.
+func Open(ctx context.Context, path string, pass []byte, vt VaultType) (Vault, error) {
+	open, ok := registry[vt]
+	if !ok {
+		return nil, fmt.Errorf("vault type %q: not implemented", vt)
+	}
+
+	type data struct {
+		v   Vault
+		err error
+	}
+
+	done := make(chan data, 1)
+	go func() {
+		defer func() {
+			for i := range pass {
+				pass[i] = 0
+			}
+		}()
+		v, err := open(path, pass)
+		done <- data{v, err}
+	}()
+
+	select {
+	case r := <-done:
+		return r.v, r.err
+	case <-ctx.Done():
+		return nil, fmt.Errorf("open: operation timed out. wrong type?")
+	}
+}
+
+// Types returns a slice of all registered vault types.
+func Types() []VaultType {
+	var s []VaultType
+	for t := range registry {
+		s = append(s, t)
+	}
+	slices.Sort(s)
+	return s
+}
+
+// StrTypes returns a comma-separated string of all registered vault types.
+func StrTypes() string {
+	var s []string
+	for _, vt := range Types() {
+		s = append(s, vt.String())
+	}
+	return strings.Join(s, ", ")
+}