feat(cache): add cache (#28)

This is completely optional.

Setting this to either `true` (default caching of `12h`),
`false` (disable completely, which should be the default),
a `number` (in seconds) or a `string` like `1d`, `2w`, `72h`, `2y`
will then store the values in a sqlite db in `.cache/kuba/db.sqlite`.

The reason behind this is,
that you might want to have your GCP secrets of your dayjob not stored/cached,
but you have a personal/hobby project,
where you want to cache your bitwarden secrets.

Author: gorillamoe

.github/workflows/web.yaml

@@ -47,6 +47,8 @@ jobs:
             linux-bun-${{ hashFiles('**/bun.lock') }}
       - name: Add kuba.schema.json to website
         run: cp kuba.schema.json web/static/kuba.schema.json
+      - name: Add kuba-global.schema.json to website
+        run: cp kuba-global.schema.json web/static/kuba-global.schema.json
       - name: Install dependencies
         run: cd web && bun install --frozen-lockfile
       - name: Create Website

cmd/kuba/cache.go

@@ -0,0 +1,374 @@
+package kuba
+
+import (
+	"fmt"
+	"path/filepath"
+	"strings"
+
+	"github.com/mistweaverco/kuba/internal/config"
+	"github.com/mistweaverco/kuba/internal/lib/cache"
+	"github.com/spf13/cobra"
+)
+
+var (
+	cachePath    string
+	cacheEnv     string
+	cacheVerbose bool
+)
+
+var cacheCmd = &cobra.Command{
+	Use:   "cache",
+	Short: "Manage kuba cache",
+	Long: `Manage the kuba secrets cache.
+
+This command allows you to:
+- List cached secrets
+- Clear cache entries
+- Show cache statistics
+- Configure cache settings
+
+The cache is stored in ~/.cache/kuba/db.sqlite and helps reduce API calls
+to cloud providers by storing secrets temporarily.`,
+	Args: cobra.NoArgs,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return runCacheCommand()
+	},
+}
+
+var cacheListCmd = &cobra.Command{
+	Use:   "list",
+	Short: "List cached secrets",
+	Long:  "List all cached secrets with their metadata.",
+	Args:  cobra.NoArgs,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return runCacheList()
+	},
+}
+
+var cacheClearCmd = &cobra.Command{
+	Use:   "clear",
+	Short: "Clear cached secrets",
+	Long: `Clear cached secrets.
+
+By default, clears all cached secrets. Use --path to clear secrets for a specific
+kuba.yaml file, or --env to clear secrets for a specific environment.`,
+	Args: cobra.NoArgs,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return runCacheClear()
+	},
+}
+
+var cacheStatsCmd = &cobra.Command{
+	Use:   "stats",
+	Short: "Show cache statistics",
+	Long:  "Show cache statistics including entry counts and configuration.",
+	Args:  cobra.NoArgs,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return runCacheStats()
+	},
+}
+
+var configCacheCmd = &cobra.Command{
+	Use:   "cache",
+	Short: "Configure cache settings",
+	Long: `Configure global cache settings.
+
+Examples:
+  kuba config cache --enable --ttl 1d
+  kuba config cache --disable
+  kuba config cache --ttl 2w`,
+	Args: cobra.NoArgs,
+	RunE: func(cmd *cobra.Command, args []string) error {
+		return runCacheConfigWithCmd(cmd)
+	},
+}
+
+func init() {
+	// Add cache command to root
+	rootCmd.AddCommand(cacheCmd)
+
+	// Add subcommands to cache
+	cacheCmd.AddCommand(cacheListCmd)
+	cacheCmd.AddCommand(cacheClearCmd)
+	cacheCmd.AddCommand(cacheStatsCmd)
+
+	// Global flags for cache commands
+	cacheCmd.PersistentFlags().StringVarP(&cachePath, "path", "p", "", "Path to kuba.yaml file")
+	cacheCmd.PersistentFlags().StringVarP(&cacheEnv, "env", "e", "", "Environment name")
+	cacheCmd.PersistentFlags().BoolVarP(&cacheVerbose, "verbose", "v", false, "Verbose output")
+
+	// Cache clear flags
+	cacheClearCmd.Flags().Bool("all", false, "Clear all cached secrets")
+	cacheClearCmd.Flags().Bool("expired", false, "Clear only expired secrets")
+
+	// Cache config flags (moved to config command)
+	configCacheCmd.Flags().Bool("enable", false, "Enable caching")
+	configCacheCmd.Flags().Bool("disable", false, "Disable caching")
+	configCacheCmd.Flags().String("ttl", "", "Set cache TTL (e.g., 1d, 2w, 72h, 2y)")
+	configCacheCmd.Flags().Bool("show", false, "Show current configuration")
+}
+
+func runCacheCommand() error {
+	fmt.Println("Kuba Cache Management")
+	fmt.Println("Use 'kuba cache --help' to see available commands.")
+	return nil
+}
+
+func runCacheList() error {
+	// Load global config
+	globalConfig, err := config.LoadGlobalConfig()
+	if err != nil {
+		return fmt.Errorf("failed to load global config: %w", err)
+	}
+
+	// Convert to cache types
+	cacheGlobalConfig := &cache.GlobalConfig{
+		Cache: cache.CacheConfig{
+			Enabled: globalConfig.Cache.Enabled,
+			TTL:     globalConfig.Cache.TTL,
+		},
+	}
+
+	// Initialize cache manager
+	manager, err := cache.NewManager(cacheGlobalConfig)
+	if err != nil {
+		return fmt.Errorf("failed to initialize cache manager: %w", err)
+	}
+	defer manager.Close()
+
+	if !manager.IsEnabled() {
+		fmt.Println("Caching is disabled.")
+		return nil
+	}
+
+	// Get cached entries
+	entries, err := manager.List()
+	if err != nil {
+		return fmt.Errorf("failed to list cache entries: %w", err)
+	}
+
+	if len(entries) == 0 {
+		fmt.Println("No cached secrets found.")
+		return nil
+	}
+
+	// Filter entries if path or env specified
+	filteredEntries := entries
+	if cachePath != "" {
+		absPath, err := filepath.Abs(cachePath)
+		if err != nil {
+			return fmt.Errorf("failed to get absolute path: %w", err)
+		}
+		var filtered []cache.CacheEntry
+		for _, entry := range entries {
+			if entry.Path == absPath {
+				filtered = append(filtered, entry)
+			}
+		}
+		filteredEntries = filtered
+	}
+
+	if cacheEnv != "" {
+		var filtered []cache.CacheEntry
+		for _, entry := range filteredEntries {
+			if entry.KubaEnv == cacheEnv {
+				filtered = append(filtered, entry)
+			}
+		}
+		filteredEntries = filtered
+	}
+
+	// Display entries
+	fmt.Printf("Found %d cached secret(s):\n\n", len(filteredEntries))
+
+	for _, entry := range filteredEntries {
+		fmt.Printf("Path: %s\n", entry.Path)
+		fmt.Printf("Environment: %s\n", entry.KubaEnv)
+		fmt.Printf("Variable: %s\n", entry.Env)
+		if cacheVerbose {
+			fmt.Printf("Value: %s\n", entry.Value)
+		} else {
+			// Mask the value for security
+			masked := maskSecret(entry.Value)
+			fmt.Printf("Value: %s\n", masked)
+		}
+		fmt.Printf("Created: %s\n", entry.CreatedAt.Format("2006-01-02 15:04:05"))
+		fmt.Printf("Expires: %s\n", entry.ExpiresAt.Format("2006-01-02 15:04:05"))
+		fmt.Println(strings.Repeat("-", 50))
+	}
+
+	return nil
+}
+
+func runCacheClear() error {
+	// Load global config
+	globalConfig, err := config.LoadGlobalConfig()
+	if err != nil {
+		return fmt.Errorf("failed to load global config: %w", err)
+	}
+
+	// Convert to cache types
+	cacheGlobalConfig := &cache.GlobalConfig{
+		Cache: cache.CacheConfig{
+			Enabled: globalConfig.Cache.Enabled,
+			TTL:     globalConfig.Cache.TTL,
+		},
+	}
+
+	// Initialize cache manager
+	manager, err := cache.NewManager(cacheGlobalConfig)
+	if err != nil {
+		return fmt.Errorf("failed to initialize cache manager: %w", err)
+	}
+	defer manager.Close()
+
+	if !manager.IsEnabled() {
+		fmt.Println("Caching is disabled.")
+		return nil
+	}
+
+	// Determine what to clear
+	if cachePath != "" && cacheEnv != "" {
+		// Clear specific environment
+		if err := manager.ClearByEnvironment(cachePath, cacheEnv); err != nil {
+			return fmt.Errorf("failed to clear cache for environment: %w", err)
+		}
+		fmt.Printf("Cleared cache for environment '%s' in %s\n", cacheEnv, cachePath)
+	} else if cachePath != "" {
+		// Clear specific path
+		if err := manager.ClearByPath(cachePath); err != nil {
+			return fmt.Errorf("failed to clear cache for path: %w", err)
+		}
+		fmt.Printf("Cleared cache for %s\n", cachePath)
+	} else {
+		// Clear all
+		if err := manager.Clear(); err != nil {
+			return fmt.Errorf("failed to clear cache: %w", err)
+		}
+		fmt.Println("Cleared all cached secrets.")
+	}
+
+	return nil
+}
+
+func runCacheStats() error {
+	// Load global config
+	globalConfig, err := config.LoadGlobalConfig()
+	if err != nil {
+		return fmt.Errorf("failed to load global config: %w", err)
+	}
+
+	// Convert to cache types
+	cacheGlobalConfig := &cache.GlobalConfig{
+		Cache: cache.CacheConfig{
+			Enabled: globalConfig.Cache.Enabled,
+			TTL:     globalConfig.Cache.TTL,
+		},
+	}
+
+	// Initialize cache manager
+	manager, err := cache.NewManager(cacheGlobalConfig)
+	if err != nil {
+		return fmt.Errorf("failed to initialize cache manager: %w", err)
+	}
+	defer manager.Close()
+
+	// Get stats
+	stats, err := manager.GetStats()
+	if err != nil {
+		return fmt.Errorf("failed to get cache stats: %w", err)
+	}
+
+	fmt.Println("Cache Statistics:")
+	fmt.Printf("Enabled: %v\n", stats["enabled"])
+
+	if enabled, ok := stats["enabled"].(bool); ok && enabled {
+		fmt.Printf("Total Entries: %v\n", stats["total_entries"])
+		fmt.Printf("TTL: %v\n", stats["ttl"])
+
+		if envCounts, ok := stats["environment_counts"].(map[string]int); ok {
+			fmt.Println("Entries by Environment:")
+			for env, count := range envCounts {
+				fmt.Printf("  %s: %d\n", env, count)
+			}
+		}
+	}
+
+	return nil
+}
+
+func runCacheConfigWithCmd(cmd *cobra.Command) error {
+	// Load current config
+	globalConfig, err := config.LoadGlobalConfig()
+	if err != nil {
+		return fmt.Errorf("failed to load global config: %w", err)
+	}
+
+	// Check if we should show current config
+	show, _ := cmd.Flags().GetBool("show")
+	if show {
+		fmt.Println("Current Cache Configuration:")
+		fmt.Printf("Enabled: %v\n", globalConfig.Cache.Enabled)
+		fmt.Printf("TTL: %s\n", globalConfig.Cache.TTL)
+		return nil
+	}
+
+	// Check for conflicting flags
+	enable, _ := cmd.Flags().GetBool("enable")
+	disable, _ := cmd.Flags().GetBool("disable")
+
+	if enable && disable {
+		return fmt.Errorf("cannot both enable and disable caching")
+	}
+
+	// Apply changes
+	modified := false
+
+	if enable {
+		globalConfig.Cache.Enabled = true
+		modified = true
+	}
+
+	if disable {
+		globalConfig.Cache.Enabled = false
+		modified = true
+	}
+
+	ttlStr, _ := cmd.Flags().GetString("ttl")
+	if ttlStr != "" {
+		duration, enabled, err := cache.ParseDuration(ttlStr)
+		if err != nil {
+			return fmt.Errorf("invalid TTL format: %w", err)
+		}
+		globalConfig.Cache.TTL = duration
+		globalConfig.Cache.Enabled = enabled
+		modified = true
+	}
+
+	if !modified {
+		fmt.Println("No changes specified. Use --help to see available options.")
+		return nil
+	}
+
+	// Save config
+	if err := config.SaveGlobalConfig(globalConfig); err != nil {
+		return fmt.Errorf("failed to save global config: %w", err)
+	}
+
+	fmt.Println("Cache configuration updated successfully.")
+	fmt.Printf("Enabled: %v\n", globalConfig.Cache.Enabled)
+	fmt.Printf("TTL: %s\n", globalConfig.Cache.TTL)
+
+	return nil
+}
+
+// maskSecret masks a secret value for display
+func maskSecret(value string) string {
+	if len(value) == 0 {
+		return ""
+	}
+	if len(value) <= 4 {
+		return strings.Repeat("*", len(value))
+	}
+	return value[:2] + strings.Repeat("*", len(value)-4) + value[len(value)-2:]
+}