feat: add simple watcher, refactor repo/cache and logging

Signed-off-by: A. Ottr <[e-mail]>

cmd/nox/main.go

···
 	"github.com/aottr/nox/internal/crypto"
 	"github.com/aottr/nox/internal/logging"
 	"github.com/aottr/nox/internal/processor"
+	"github.com/aottr/nox/internal/watcher"
 	"github.com/urfave/cli/v3"
 )
 
 func main() {
 
-	logging.Init()
+	logging.InitTextLogger()
 	logging.SetLevel("info")
 	log := logging.Get()
 
···
 			},
 		},
 		Commands: []*cli.Command{
-			// {
-			// 	Name:    "run",
-			// 	Aliases: []string{"r"},
-			// 	Usage:   "Fetch, decrypt, and process app secrets",
-			// 	Action: func(ctx context.Context, cmd *cli.Command) error {
-			// 		cfg, err := config.Load(configPath)
-			// 		if err != nil {
-			// 			log.Fatalf("failed to load config: %v", err)
-			// 		}
-			// 		return processor.ProcessApps(cfg)
-			// 	},
-			// },
 			{
 				Name:    "encrypt",
 				Aliases: []string{"enc"},
···
 				Name: "init",
 				Action: func(ctx context.Context, cmd *cli.Command) error {
 					return config.InitConfig(configPath)
+				},
+			},
+			{
+				Name: "watch",
+				Action: func(ctx context.Context, cmd *cli.Command) error {
+					cfg, _ := config.Load(configPath)
+					watcher.Start(cfg)
+					return nil
 				},
 			},
 		},

internal/cache/repocache.go

···
 
 	"github.com/aottr/nox/internal/config"
 	"github.com/aottr/nox/internal/git"
-	"github.com/go-git/go-git/v5/plumbing/object"
 )
 
 type RepoKey struct {
···
 
 type RepoCache struct {
 	mu    sync.RWMutex
-	repos map[RepoKey]*object.Tree
+	repos map[RepoKey]*git.ClonedRepo
+	// sf    singleflight.Group TODO
 }
 
 var (
 	GlobalCache = &RepoCache{
-		repos: make(map[RepoKey]*object.Tree),
+		repos: make(map[RepoKey]*git.ClonedRepo),
 	}
 )
 
-func (c *RepoCache) Get(key RepoKey) (*object.Tree, bool) {
+func (c *RepoCache) Get(key RepoKey) (*git.ClonedRepo, bool) {
 	c.mu.RLock()
 	defer c.mu.RUnlock()
 	tree, exists := c.repos[key]
 	return tree, exists
 }
 
-func (c *RepoCache) Set(key RepoKey, tree *object.Tree) {
+func (c *RepoCache) Set(key RepoKey, repo *git.ClonedRepo) {
 	c.mu.Lock()
 	defer c.mu.Unlock()
-	c.repos[key] = tree
+	c.repos[key] = repo
 }
 
-func (c *RepoCache) FetchRepo(key RepoKey) (*object.Tree, error) {
+func (c *RepoCache) FetchRepo(key RepoKey) (*git.ClonedRepo, error) {
 	r, err := git.CloneRepo(config.GitConfig{
 		Repo:   key.Repo,
 		Branch: key.Branch,
···
 		return nil, err
 	}
 
-	c.Set(key, r.Tree)
-	return r.Tree, nil
+	c.Set(key, r)
+	return r, nil
+}
+
+func (c *RepoCache) GetOrFetch(key RepoKey) (*git.ClonedRepo, error) {
+	tree, exists := c.Get(key)
+	if exists {
+		return tree, nil
+	} else {
+		return c.FetchRepo(key)
+	}
+}
+
+func (c *RepoCache) RefreshCache() error {
+	c.mu.RLock()
+	repos := make([]*git.ClonedRepo, 0, len(c.repos))
+	for _, r := range c.repos {
+		repos = append(repos, r)
+	}
+	c.mu.RUnlock()
+
+	for _, repo := range repos {
+		if err := repo.Refresh(); err != nil {
+			return err
+		}
+	}
+	return nil
+}
+
+func (c *RepoCache) Has(key RepoKey) bool {
+	c.mu.RLock()
+	defer c.mu.RUnlock()
+	_, exists := c.repos[key]
+	return exists
 }
 
 func ClearRepoCache() {
 	GlobalCache.mu.Lock()
 	defer GlobalCache.mu.Unlock()
-	GlobalCache.repos = make(map[RepoKey]*object.Tree)
+	GlobalCache.repos = make(map[RepoKey]*git.ClonedRepo)
 }

internal/config/config.go

···
 import (
 	"fmt"
 	"os"
+	"time"
 
 	"gopkg.in/yaml.v3"
 )
···
 }
 
 type Config struct {
-	Interval  string               `yaml:"interval"`
-	Age       AgeConfig            `yaml:"age"`
-	StatePath string               `yaml:"statePath"`
-	GitConfig GitConfig            `yaml:"git"`
-	Apps      map[string]AppConfig `yaml:"apps"`
+	Interval       time.Duration        `yaml:"-"`
+	IntervalString string               `yaml:"interval"`
+	Age            AgeConfig            `yaml:"age"`
+	StatePath      string               `yaml:"statePath"`
+	GitConfig      GitConfig            `yaml:"git"`
+	Apps           map[string]AppConfig `yaml:"apps"`
 }
 
 func Load(path string) (*Config, error) {
···
 		return nil, fmt.Errorf("no git configuration found: set either top-level git or app-specific git")
 	}
 
+	// validate interval
+	cfg.Interval, err = time.ParseDuration(cfg.IntervalString)
+	if err != nil {
+		return nil, fmt.Errorf("invalid interval: %w", err)
+	}
 	return &cfg, nil
 }
 
···
 	}
 
 	cfg := Config{
-		Interval:  "10m",
-		StatePath: ".nox-state.json",
+		IntervalString: "10m",
+		StatePath:      ".nox-state.json",
 		GitConfig: GitConfig{
 			Repo:   "",
 			Branch: "main",

internal/config/context.go

···
 
 import (
 	"fmt"
-	"io"
-	"log"
-	"os"
 
 	"filippo.io/age"
 	"github.com/aottr/nox/internal/crypto"
···
 	Config     *Config
 	State      *state.State
 	Identities []age.Identity
-	App        *string
-	Logger     *log.Logger
+	App        string
 	DryRun     bool
 	Force      bool
-	Verbose    bool
+}
+
+func BuildRuntimeCtxFromConfig(config *Config) (*RuntimeContext, error) {
+
+	if config.StatePath != "" {
+		state.SetPath(config.StatePath)
+	}
+	st, err := state.Load()
+	if err != nil {
+		return nil, err
+	}
+
+	var identityPaths []string
+	// try single identity file first
+	if config.Age.Identity != "" {
+		identityPaths = []string{config.Age.Identity}
+	} else if len(config.Age.Identities) > 0 {
+		identityPaths = config.Age.Identities
+	} else {
+		return nil, fmt.Errorf("no age identites found")
+	}
+	ids, err := crypto.LoadAgeIdentitiesFromPaths(identityPaths)
+	if err != nil {
+		return nil, err
+	}
+
+	return &RuntimeContext{
+		Config:     config,
+		State:      st,
+		Identities: ids,
+		DryRun:     false,
+		Force:      false,
+	}, nil
 }
 
 func BuildRuntimeContext(opts RuntimeOptions) (*RuntimeContext, error) {
···
 		return nil, err
 	}
 
-	var app *string
+	var app string
 	if opts.AppName != "" {
 		if _, exists := cfg.Apps[opts.AppName]; exists {
-			app = &opts.AppName
+			app = opts.AppName
 		} else {
 			return nil, fmt.Errorf("app '%s' not found in configuration", opts.AppName)
 		}
 	}
 
-	var logger *log.Logger
-	if opts.Verbose {
-		logger = log.New(os.Stdout, "", log.LstdFlags)
-	} else {
-		logger = log.New(io.Discard, "", 0)
-	}
-
 	return &RuntimeContext{
 		Config:     cfg,
 		State:      st,
 		Identities: ids,
 		App:        app,
-		Logger:     logger,
 		DryRun:     opts.DryRun,
 		Force:      opts.Force,
-		Verbose:    opts.Verbose,
 	}, nil
 }

internal/git/repo.go

···
 
 type ClonedRepo struct {
 	Repo   *git.Repository
+	Branch string
 	Tree   *object.Tree
 	Ref    *plumbing.Reference
 	Commit *object.Commit
···
 	}
 	return &ClonedRepo{
 		Repo:   repo,
+		Branch: c.Branch,
 		Ref:    ref,
 		Commit: commit,
 		Tree:   tree,
···
 	}
 
 	return content, nil
+}
+
+func (r *ClonedRepo) Refresh() error {
+	if err := r.Repo.Fetch(&git.FetchOptions{
+		RemoteName: "origin",
+		Force:      true,
+		Prune:      true,
+	}); err != nil && err != git.NoErrAlreadyUpToDate {
+		return fmt.Errorf("fetch: %w", err)
+	}
+	remoteRef := plumbing.NewRemoteReferenceName("origin", r.Branch)
+	ref, err := r.Repo.Reference(remoteRef, true)
+	if err != nil {
+		return err
+	}
+	r.Ref = ref
+
+	commit, err := r.Repo.CommitObject(r.Ref.Hash())
+	if err != nil {
+		return err
+	}
+	r.Commit = commit
+	tree, err := commit.Tree()
+	if err != nil {
+		return err
+	}
+	r.Tree = tree
+	return nil
 }
 
 func FileExistsInTree(tree *object.Tree, path string) bool {

internal/logging/cli_handler.go

···
+package logging
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"log/slog"
+)
+
+type CliHandler struct {
+	w     io.Writer
+	level slog.Leveler
+}
+
+func (h *CliHandler) Enabled(_ context.Context, level slog.Level) bool {
+	minLevel := slog.LevelInfo
+	if h.level != nil {
+		minLevel = h.level.Level()
+	}
+	return level >= minLevel
+}
+
+func NewCliHandler(w io.Writer, level slog.Leveler) slog.Handler {
+	h := &CliHandler{w: w, level: level}
+	return h
+}
+
+func (h *CliHandler) Handle(_ context.Context, r slog.Record) error {
+
+	attrs := ""
+	r.Attrs(func(a slog.Attr) bool {
+		if a.Key == "error" {
+			attrs += fmt.Sprintf("%v ", a.Value)
+			return true
+		}
+		return false
+	})
+
+	if attrs != "" {
+		fmt.Fprintf(h.w, "%s: %s\n", r.Message, attrs[:len(attrs)-1])
+	} else {
+		fmt.Fprintln(h.w, r.Message)
+	}
+	return nil
+}
+
+func (h *CliHandler) WithAttrs(attrs []slog.Attr) slog.Handler { return h }
+func (h *CliHandler) WithGroup(name string) slog.Handler       { return h }

internal/logging/logger.go

···
 	return logger
 }
 
+func InitTextLogger() {
+	once.Do(func() {
+		logLevel.Set(slog.LevelInfo)
+		h := NewCliHandler(os.Stdout, logLevel)
+		logger = slog.New(h)
+	})
+}
+
 func Init() {
 	once.Do(func() {
 		logLevel.Set(slog.LevelInfo)
-
-		h := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{
-			Level: logLevel,
-		})
+		h := slog.NewJSONHandler(os.Stdout, &slog.HandlerOptions{Level: slog.LevelError})
 		logger = slog.New(h)
 	})
 }

internal/processor/fsutil.go

···
 	"github.com/aottr/nox/internal/constants"
 )
 
-type FileProcessorOptions struct {
-	CreateDir bool
-}
-
-func WriteToFile(data []byte, file config.FileConfig, opts *FileProcessorOptions) error {
+func WriteToFile(data []byte, file config.FileConfig) error {
 	path := file.Output
 	if path == "" {
 		// Default output filename if none specified, e.g. replace .age with .env
···
 			path = path[:len(path)-4] + ".env"
 		}
 	}
-	if opts.CreateDir {
-		if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
-			return fmt.Errorf("failed to create directories for %s: %w", path, err)
-		}
+	if err := os.MkdirAll(filepath.Dir(path), 0755); err != nil {
+		return fmt.Errorf("failed to create directories for %s: %w", path, err)
 	}
 
 	if err := os.WriteFile(path, data, 0600); err != nil {

internal/processor/gitsync.go

···
-package processor
-
-import (
-	"fmt"
-	"os"
-
-	"github.com/aottr/nox/internal/cache"
-	"github.com/aottr/nox/internal/config"
-	"github.com/aottr/nox/internal/crypto"
-	"github.com/aottr/nox/internal/git"
-	"github.com/aottr/nox/internal/state"
-)
-
-func SyncApp(ctx *config.RuntimeContext) error {
-
-	cfg, appName, identities, st := ctx.Config, ctx.App, ctx.Identities, ctx.State
-
-	if appName == nil {
-		return fmt.Errorf("app name is required")
-	}
-
-	// retrieve app config and repository
-	app := cfg.Apps[*appName]
-	repoUrl := app.GitConfig.Repo
-	if repoUrl == "" {
-		repoUrl = cfg.GitConfig.Repo
-	}
-	branchName := app.GitConfig.Branch
-	if branchName == "" {
-		branchName = cfg.GitConfig.Branch
-	}
-
-	key := cache.RepoKey{Repo: repoUrl, Branch: branchName}
-	repo, exists := cache.GlobalCache.Get(key)
-	if !exists {
-		var err error
-		repo, err = cache.GlobalCache.FetchRepo(key)
-		if err != nil {
-			return fmt.Errorf("failed to fetch repo for app %s: %w", *appName, err)
-		}
-	}
-
-	// iterate over files and decrypt
-	for _, file := range app.Files {
-		content, err := git.GetFileContentFromTree(repo, file.Path)
-		if err != nil {
-			return fmt.Errorf("failed to get file %s: %w", file, err)
-		}
-
-		hash := state.HashContent(content)
-		cacheKey := state.GenerateKey(*appName, file.Path)
-
-		// skip if file is up to date and force is not set
-		if !ctx.Force && !ctx.DryRun {
-			if prevHash, ok := st.Data[cacheKey]; ok && prevHash == hash {
-				ctx.Logger.Printf("file %s is up to date", file.Path)
-				continue
-			}
-		}
-
-		// decrypt file
-		plaintext, err := crypto.DecryptBytes(content, identities)
-		if err != nil {
-			ctx.Logger.Printf("failed to decrypt file %s: %v", file.Path, err)
-			continue
-		}
-
-		// skip writing file if dry run is set
-		if ctx.DryRun {
-			ctx.Logger.Printf("dry run, not writing file %s", file.Output)
-			os.Stdout.Write(plaintext)
-			continue
-		}
-		WriteToFile(plaintext, file, &FileProcessorOptions{CreateDir: true})
-
-		ctx.Logger.Printf("decrypted %s for app %s (size: %d bytes)", file, *appName, len(plaintext))
-
-		// update state
-		st.Data[cacheKey] = hash
-		st.Touch()
-	}
-
-	if err := state.Save(st); err != nil {
-		return fmt.Errorf("failed to save state: %w", err)
-	}
-	return nil
-}
-
-func SyncApps(ctx *config.RuntimeContext) error {
-	for appName := range ctx.Config.Apps {
-		ctx.App = &appName
-		ctx.Logger.Printf("Processing app: %s\n", appName)
-		if err := SyncApp(ctx); err != nil {
-			return err
-		}
-	}
-	return nil
-}

internal/processor/sync.go

···
+package processor
+
+import (
+	"fmt"
+	"os"
+
+	"github.com/aottr/nox/internal/cache"
+	"github.com/aottr/nox/internal/config"
+	"github.com/aottr/nox/internal/crypto"
+	"github.com/aottr/nox/internal/git"
+	"github.com/aottr/nox/internal/logging"
+	"github.com/aottr/nox/internal/state"
+)
+
+func SyncApp(ctx *config.RuntimeContext) error {
+
+	log := logging.Get()
+	var err error
+	cfg, appName, identities, st := ctx.Config, ctx.App, ctx.Identities, ctx.State
+
+	if appName == "" {
+		return fmt.Errorf("app name is required")
+	}
+
+	// retrieve app config and repository
+	app := cfg.Apps[appName]
+	gitConf := app.GitConfig
+	if !gitConf.IsValid() {
+		gitConf = cfg.GitConfig
+	}
+
+	key := cache.RepoKey{Repo: gitConf.Repo, Branch: gitConf.Branch}
+	repo, err := cache.GlobalCache.GetOrFetch(key)
+	if err != nil {
+		return fmt.Errorf("failed to fetch repo for app %s: %w", appName, err)
+	}
+
+	// iterate over files and decrypt
+	for _, file := range app.Files {
+		content, err := git.GetFileContentFromTree(repo.Tree, file.Path)
+		if err != nil {
+			return fmt.Errorf("failed to get file %s: %w", file, err)
+		}
+
+		hash := state.HashContent(content)
+		cacheKey := state.GenerateKey(appName, file.Path)
+
+		// skip if file is up to date and force is not set
+		if !ctx.Force && !ctx.DryRun {
+			if prevHash, ok := st.Data[cacheKey]; ok && prevHash == hash {
+				log.Debug(fmt.Sprintf("file %s is up to date", file.Path))
+				continue
+			}
+		}
+
+		// decrypt file
+		plaintext, err := crypto.DecryptBytes(content, identities)
+		if err != nil {
+			log.Warn("failed to decrypt file %s: %v", file.Path, err)
+			continue
+		}
+
+		// skip writing file if dry run is set
+		if ctx.DryRun {
+			log.Debug(fmt.Sprintf("dry run, not writing file %s", file.Output))
+			os.Stdout.Write(plaintext)
+			continue
+		}
+		if err := WriteToFile(plaintext, file); err != nil {
+			log.Error("failed to write file %s: %v", file.Output, err)
+			continue
+		}
+
+		log.Debug(fmt.Sprintf("decrypted %s for app %s (size: %d bytes)", file, appName, len(plaintext)))
+
+		// update state
+		st.Data[cacheKey] = hash
+		st.Touch()
+	}
+
+	if err := state.Save(st); err != nil {
+		return fmt.Errorf("failed to save state: %w", err)
+	}
+	return nil
+}
+
+func SyncApps(ctx *config.RuntimeContext) error {
+	for appName := range ctx.Config.Apps {
+		ctx.App = appName
+		logging.Get().Debug(fmt.Sprintf("Processing app: %s", appName))
+		if err := SyncApp(ctx); err != nil {
+			return err
+		}
+	}
+	return nil
+}

internal/processor/validate.go

···
 
 import (
 	"fmt"
-	// "os"
-	// "path/filepath"
-	// "strings"
 
 	"github.com/aottr/nox/internal/config"
 	"github.com/aottr/nox/internal/git"

internal/state/state.go

···
 
 import (
 	"encoding/json"
-	"log"
 	"os"
 	"time"
 )
···
 	Data        map[string]string
 }
 
-var defaultPath = ".nox-state.json" // fallback default
+var defaultPath = ".nox-state.json"
 
 // SetPath updates the default file path used for saving and loading state
 func SetPath(path string) {
···
 }
 
 // Load reads the state from the state file
-// Returns an error if the file cannot be read or unmarshaled.
 func Load() (*State, error) {
 	return loadFromFile(defaultPath)
 }
···
 func loadFromFile(path string) (*State, error) {
 	data, err := os.ReadFile(path)
 	if err != nil {
-		log.Printf("⚠️ No previous state found, starting fresh: %v", err)
 		return &State{Data: make(map[string]string)}, nil
 	}
-
 	var state State
 	if err := json.Unmarshal(data, &state); err != nil {
 		return nil, err

internal/watcher/watcher.go

···
+package watcher
+
+import (
+	"fmt"
+	"time"
+
+	"github.com/aottr/nox/internal/cache"
+	"github.com/aottr/nox/internal/config"
+	"github.com/aottr/nox/internal/logging"
+	"github.com/aottr/nox/internal/processor"
+)
+
+func Start(cfg *config.Config) {
+	log := logging.Get()
+	logging.SetLevel("debug")
+	ticker := time.NewTicker(cfg.Interval)
+	defer ticker.Stop()
+
+	ctx, err := config.BuildRuntimeCtxFromConfig(cfg)
+	if err != nil {
+		log.Error("error building runtime context", "error", err.Error())
+		return
+	}
+	log.Info(fmt.Sprintf("Starting watcher (interval: %s)\n", cfg.Interval))
+
+	for {
+		if err := cache.GlobalCache.RefreshCache(); err != nil {
+			log.Error("error pre-fetching secrets", "error", err.Error())
+		}
+		if err := processor.SyncApps(ctx); err != nil {
+			log.Error("error syncing secrets", "error", err.Error())
+		}
+		<-ticker.C
+	}
+}