feat: add simple enc/dec with generic io wrapper

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

.nox.yaml

···
 age: 
   identity: "keys/key.txt"
   recipients:
-    - "age1nuxu3q9wr5wrd53dj8hj5flhz86q2dpjyuq7agseh0wzwq5t696s2dm0ht"
+    - "age1qq5sazxv755u2vs5ulyl486jxhlg7ztrvm27nya47aln668xldkqsm4kn5"
 statePath: ".nox-state.json"
 defaultRepo: [e-mail]:ShorkBytes/nox-secrets.git
 

cmd/nox/main.go

···
 		Flags: []cli.Flag{
 			&cli.StringFlag{
 				Name:        "config",
+				Aliases:     []string{"c"},
 				Value:       constants.DefaultConfigPath,
 				Usage:       "path to config file",
 				Destination: &configPath,
···
 					},
 				},
 				Action: func(ctx context.Context, cmd *cli.Command) error {
-					fmt.Println("encrypting file", inputPath)
-					fmt.Println("writing to", outputPath)
 					recipients, err := crypto.StringsToRecipients(cmd.StringSlice("recipient"))
 					if err != nil {
 						return err
 					}
-					out, err := crypto.EncryptFile(inputPath, recipients)
-					if err != nil {
+					if err := processor.IOWrapper(inputPath, outputPath, recipients, crypto.EncryptBytes); err != nil {
 						return err
 					}
-					fmt.Println(string(out))
-					// priv, pub, err := crypto.GenerateAndWriteX25519Identity("test.key")
-					// if err != nil {
-					// 	return err
-					// }
-					// fmt.Println(priv)
-					// fmt.Println(pub)
-
 					return nil
 				},
 			},
 			{
-				Name: "generate",
+				Name:    "decrypt",
+				Aliases: []string{"dec"},
+				Usage:   "Decrypt a file",
 				Flags: []cli.Flag{
+					&cli.StringFlag{
+						Name:        "input",
+						Usage:       "path to input file",
+						Aliases:     []string{"i"},
+						Value:       constants.StandardInput,
+						Destination: &inputPath,
+					},
 					&cli.StringFlag{
 						Name:        "output",
 						Usage:       "path to output file",
···
 					},
 				},
 				Action: func(ctx context.Context, cmd *cli.Command) error {
-					priv, pub, err := crypto.GenerateIdentity(cmd.String("output"))
+					identities, err := crypto.LoadAgeIdentitiesFromPaths(identityPaths)
 					if err != nil {
 						return err
 					}
-					fmt.Println(priv)
-					fmt.Println(pub)
+					return processor.IOWrapper(inputPath, constants.StandardOutput, identities, crypto.DecryptBytes)
+				},
+			},
+			{
+				Name: "generate",
+				Flags: []cli.Flag{
+					&cli.StringFlag{
+						Name:        "output",
+						Usage:       "path to output file",
+						Aliases:     []string{"o"},
+						Value:       constants.StandardOutput,
+						Destination: &outputPath,
+					},
+				},
+				Action: func(ctx context.Context, cmd *cli.Command) error {
+
+					output := cmd.String("output")
+					switch output {
+					case constants.StandardOutput:
+						priv, pub, err := crypto.GenerateIdentity("")
+						if err != nil {
+							return err
+						}
+						fmt.Println("Public key:\n", pub, "\nPrivate Key:\n", priv)
+					default:
+						_, _, err := crypto.GenerateIdentity(cmd.String("output"))
+						if err != nil {
+							return err
+						}
+					}
+
 					return nil
 				},
 			},
 			{
-				Name:    "decrypt",
-				Aliases: []string{"d"},
-				Usage:   "Decrypts all secrets of one or all apps",
+				Name:    "sync",
+				Aliases: []string{"fetch"},
+				Usage:   "Fetches and decrypts all secrets of one or all apps",
 				Flags: []cli.Flag{
 					&cli.StringFlag{
 						Name:    "app",

internal/crypto/encrypt.go

···
 	}
 
 	if _, err := io.Copy(enc, src); err != nil {
-		enc.Close() // ensure resources are freed
+		enc.Close()
 		return nil, fmt.Errorf("encryption failed: %w", err)
 	}
 

internal/crypto/identity.go

···
 	priv = id.String()            // "AGE-SECRET-KEY-1..."
 	pub = id.Recipient().String() // "age1..."
 
+	if path == "" {
+		return priv, pub, nil
+	}
+
 	// ensure directory exists and apply permissions
 	if err := os.MkdirAll(filepath.Dir(path), 0o700); err != nil {
 		return "", "", fmt.Errorf("mkdir %s: %w", filepath.Dir(path), err)

internal/processor/file.go

···
-package processor
-
-import (
-	"fmt"
-	"os"
-	"path/filepath"
-
-	"github.com/aottr/nox/internal/config"
-)
-
-type FileProcessorOptions struct {
-	CreateDir bool
-}
-
-func WriteToFile(data []byte, file config.FileConfig, opts *FileProcessorOptions) error {
-	path := file.Output
-	if path == "" {
-		// Default output filename if none specified, e.g. replace .age with .env
-		path = filepath.Base(file.Path)
-		fmt.Println(path)
-		if filepath.Ext(path) == ".age" {
-			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.WriteFile(path, data, 0600); err != nil {
-		return fmt.Errorf("failed to write decrypted file to %s: %w", path, err)
-	}
-	return nil
-}

internal/processor/fsutil.go

···
+package processor
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+
+	"github.com/aottr/nox/internal/config"
+	"github.com/aottr/nox/internal/constants"
+)
+
+type FileProcessorOptions struct {
+	CreateDir bool
+}
+
+func WriteToFile(data []byte, file config.FileConfig, opts *FileProcessorOptions) error {
+	path := file.Output
+	if path == "" {
+		// Default output filename if none specified, e.g. replace .age with .env
+		path = filepath.Base(file.Path)
+		fmt.Println(path)
+		if filepath.Ext(path) == ".age" {
+			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.WriteFile(path, data, 0600); err != nil {
+		return fmt.Errorf("failed to write decrypted file to %s: %w", path, err)
+	}
+	return nil
+}
+
+// IOWrapper is a generic wrapper for reading/writing files/STDIN/STDOUT
+func IOWrapper[T any](input, output string, additional T, process func([]byte, T) ([]byte, error)) error {
+	var inputBytes []byte
+	var err error
+
+	if input == constants.StandardInput {
+		inputBytes, err = io.ReadAll(os.Stdin)
+		if err != nil {
+			return err
+		}
+	} else {
+		inputBytes, err = os.ReadFile(input)
+		if err != nil {
+			return err
+		}
+	}
+
+	outbutBytes, err := process(inputBytes, additional)
+	if err != nil {
+		return err
+	}
+
+	if output == constants.StandardOutput {
+		if _, err = os.Stdout.Write(outbutBytes); err != nil {
+			return err
+		}
+	} else {
+		if err = os.WriteFile(output, outbutBytes, 0600); err != nil {
+			return err
+		}
+	}
+	return nil
+}