chore: cleanup, change dryrun to stdout

README.md

···
 
 ```yaml
 interval: "10m"
-ageKeyPath: "keys/key.txt"
+age: 
+  identity: "keys/key.txt"
+  recipients: # optional, when used to encrypt secrets
+    - "age1xxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxxx"
 statePath: ".nox-state.json"
 defaultRepo: [e-mail]:ShorkBytes/nox-secrets.git
 
···
 
 ```bash
 nox --help
+```
+
+### How to
+
+#### Decrypt secret into custom file
+
+```bash
+nox decrypt --app debug --dry-run > secrets.env
 ```
 
 ### Contributing

cmd/nox/main.go

···
 	var configPath string
 	var statePath string
 	var identityPaths []string
-	var appName string
+
 	var dryRun bool
 	var force bool
 	var verbose bool
···
 				},
 			},
 			{
-				Name:    "export",
-				Aliases: []string{"e"},
-				Usage:   "Export all secrets to a single file",
+				Name:    "decrypt",
+				Aliases: []string{"d"},
+				Usage:   "Decrypts all secrets of one or all apps",
 				Flags: []cli.Flag{
 					&cli.StringFlag{
-						Name:        "app",
-						Aliases:     []string{"a"},
-						Usage:       "app to export secrets for",
-						Destination: &appName,
+						Name:    "app",
+						Aliases: []string{"a"},
+						Usage:   "app to decrypt secrets for",
 					},
 					&cli.BoolFlag{
 						Name:        "dry-run",
 						Aliases:     []string{"d"},
 						Value:       false,
-						Usage:       "only print what would be exported",
+						Usage:       "only print what would be decrypted",
 						Destination: &dryRun,
 					},
 					&cli.BoolFlag{
···
 						IdentityPaths: identityPaths,
 						DryRun:        dryRun,
 						Force:         force,
-						AppName:       appName,
+						AppName:       cmd.String("app"),
 						Verbose:       verbose,
 					})
 					if err != nil {
 						log.Fatalf("failed to build runtime context: %v", err)
 					}
-					if appName != "" {
+					if cmd.String("app") != "" {
 						return processor.SyncApp(rtx)
 					}
 					return processor.SyncApps(rtx)

internal/gitrepo/utils.go

···
 func FileExistsInTree(tree *object.Tree, path string) bool {
 	_, err := tree.File(path)
 	return err == nil
-}
+}

internal/processor/gitsync.go

···
 
 import (
 	"fmt"
+	"os"
 
 	"github.com/aottr/nox/internal/cache"
 	"github.com/aottr/nox/internal/config"
···
 		cacheKey := state.GenerateKey(*appName, file.Path)
 
 		// skip if file is up to date and force is not set
-		if !ctx.Force {
+		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
···
 		// skip writing file if dry run is set
 		if ctx.DryRun {
 			ctx.Logger.Printf("❌ dry run, not writing file %s", file.Output)
-			fmt.Println(string(plaintext))
+			os.Stdout.Write(plaintext)
 			continue
 		}
 		WriteToFile(plaintext, file, &FileProcessorOptions{CreateDir: true})

internal/state/utils.go

···
 package state
 
 import (
-	"fmt"
 	"crypto/sha256"
 	"encoding/hex"
+	"fmt"
 )
 
 // HashContent returns the SHA256 hash of the given data.
···
 
 func GenerateKey(appName, file string) string {
 	return fmt.Sprintf("%s:%s", appName, file)
-}
+}