main.go

package main

import (
	"context"
	"fmt"
	"maps"
	"os"
	"path/filepath"
	"slices"
	"strings"

	"github.com/charmbracelet/huh/spinner"
	"github.com/charmbracelet/log"
	"github.com/quintisimo/macfigure/internal/lock"
	"github.com/quintisimo/macfigure/internal/programs"
	"github.com/quintisimo/macfigure/internal/programs/brew"
	"github.com/quintisimo/macfigure/internal/programs/config"
	"github.com/quintisimo/macfigure/internal/programs/cron"
	"github.com/quintisimo/macfigure/internal/programs/dock"
	"github.com/quintisimo/macfigure/internal/programs/home"
	"github.com/quintisimo/macfigure/internal/programs/nsglobaldomain"
	"github.com/quintisimo/macfigure/internal/programs/secret"
	"github.com/urfave/cli/v3"
)

var version = "dev"

func main() {
	defaultLogLevel := "info"
	logLevels := map[string]log.Level{
		"debug":         log.DebugLevel,
		defaultLogLevel: log.InfoLevel,
		"warn":          log.WarnLevel,
		"error":         log.ErrorLevel,
	}
	logLevelKeys := slices.Collect(maps.Keys(logLevels))

	var parsedConfig config.Config
	var configDir string
	var configFlag *cli.StringFlag = &cli.StringFlag{
		Name:      "config",
		Aliases:   []string{"c"},
		Usage:     "Path to the configuration `file`",
		TakesFile: true,
		Required:  true,
		Action: func(ctx context.Context, cmd *cli.Command, path string) error {
			var parsingErr error
			configDir = filepath.Dir(path)
			parsedConfig, parsingErr = config.LoadFromPath(context.Background(), path)
			return parsingErr
		},
	}

	cli := &cli.Command{
		Name:  "macfigure",
		Usage: "A tool to manage macOS configurations",
		Flags: []cli.Flag{
			&cli.BoolFlag{
				Name:    "dry-run",
				Aliases: []string{"d"},
				Value:   false,
				Usage:   "Perform a dry run without making any changes",
			},
		},
		Commands: []*cli.Command{
			{
				Name:  "version",
				Usage: "Cli version",
				Action: func(ctx context.Context, cmd *cli.Command) error {
					fmt.Printf("Version: %s\n", version)
					return nil
				},
			},
			{
				Name:  "sync",
				Usage: "Sync system with config",
				Flags: []cli.Flag{
					configFlag,
					&cli.StringFlag{
						Name:    "loglevel",
						Aliases: []string{"l"},
						Usage:   fmt.Sprintf("Set log level, can be `%s`", strings.Join(logLevelKeys, ", ")),
						Value:   defaultLogLevel,
						Validator: func(s string) error {
							if !slices.Contains(logLevelKeys, s) {
								return fmt.Errorf("invalid log level: %s", s)
							}
							return nil
						},
					},
				},
				Action: func(ctx context.Context, cmd *cli.Command) error {
					return spinner.New().
						Title("Applying config...").
						ActionWithErr(func(context.Context) error {
							dryRun := cmd.Bool("dry-run")
							logLevel := logLevels[cmd.String("loglevel")]

							lockConfig, lockConfigErr := lock.Get(configDir, logLevel, dryRun)
							if lockConfigErr != nil {
								return lockConfigErr
							}

							programsErr := programs.RunInParallel([]programs.Execution{
								&brew.BrewProgram{
									Program: programs.Program[brew.Brew]{
										Name:  "brew",
										Input: parsedConfig.Brew,
									},
								},
								&nsglobaldomain.NSGlobalDomainProgram{
									Program: programs.Program[nsglobaldomain.Nsglobaldomain]{
										Name:  "nsglobaldomain",
										Input: parsedConfig.Nsglobaldomain,
									},
								},
								&home.HomeProgram{
									Program: programs.Program[[]home.Home]{
										Name:  "home",
										Input: parsedConfig.Home,
									},
									ExisitingHome: lockConfig,
								},
								&cron.CronProgram{
									Program: programs.Program[[]cron.Cron]{
										Name:  "cron",
										Input: parsedConfig.Cron,
									},
								},
								&secret.SecretProgram{
									Program: programs.Program[[]secret.Secret]{
										Name:  "secret",
										Input: parsedConfig.Secret,
									},
									ExistingSecret: lockConfig,
								},
								&dock.DockProgram{
									Program: programs.Program[dock.Dock]{
										Name:  "dock",
										Input: parsedConfig.Dock,
									},
								},
							}, logLevel, dryRun)

							if programsErr != nil {
								return programsErr
							}

							lock.DeleteRemoved(lockConfig, logLevel, dryRun)
							return lock.Create(parsedConfig.Home, parsedConfig.Secret, configDir, logLevel, dryRun)
						}).
						Run()
				},
			},
			{
				Name:  "secret",
				Usage: "Manage secrets with age",
				Flags: []cli.Flag{
					configFlag,
				},
				Commands: []*cli.Command{
					{
						Name:  "keychain",
						Usage: "Manage secrets encryption and decryption key in the macOS keychain",
						Commands: []*cli.Command{
							{
								Name:  "generate",
								Usage: "Generate age key and store it in the macOS keychain",
								Action: func(ctx context.Context, cmd *cli.Command) error {
									return secret.GenerateKeys()
								},
							},
							{
								Name:  "get",
								Usage: "Get the stored age public key from the macOS keychain",
								Action: func(ctx context.Context, cmd *cli.Command) error {
									if encryptionKeyPrintErr := secret.EncryptionKeyItem.Print(); encryptionKeyPrintErr != nil {
										return encryptionKeyPrintErr
									}

									if decryptionKeyPrintErr := secret.DecryptionKeyItem.Print(); decryptionKeyPrintErr != nil {
										return decryptionKeyPrintErr
									}

									return nil
								},
							},
						},
					},
					{
						Name:  "edit",
						Usage: "Edit a secrets file",
						Action: func(ctx context.Context, cmd *cli.Command) error {
							secretPath, secretErr := secret.List(parsedConfig.Secret)
							if secretErr != nil {
								return secretErr
							}

							if secretPath != "" {
								return secret.Edit(secretPath)
							}

							return nil
						},
					},
				},
			},
		},
	}

	if cliErr := cli.Run(context.Background(), os.Args); cliErr != nil {
		log.Fatal(cliErr)
	}
}