Release v1.0.0

Author: kevinzehnder

.gitignore

@@ -16,6 +16,7 @@
 
 !README.md
 !LICENSE
+!CHANGELOG.md
 
 !Taskfile.yaml
 !.goreleaser.yaml
@@ -32,4 +33,3 @@ dist/
 !devbox.json
 !devbox.lock
 !.envrc
-

CHANGELOG.md

@@ -0,0 +1,26 @@
+# Changelog
+
+All notable changes to this project will be documented in this file.
+
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.0.0/).
+
+## [1.0.0] - 2026-01-08
+
+### Added
+- Thread-safe tag caching to prevent race conditions during concurrent uploads
+- Filename sanitization for disk writes (removes invalid filesystem characters)
+- ZIP slip vulnerability protection for archive extraction
+- File validation at process start to prevent deadlocks
+- Comprehensive unit tests (coverage: 25.9% → 40.1%)
+
+### Fixed
+- Worker early termination bug where `break` was used instead of `continue`
+- Tag cache infinite retry loop in integration tests
+- Error chain preservation (replaced `%v` with `%w` throughout codebase)
+- HTTP client timeout consistency (100s → 10s)
+
+### Security
+- Path traversal protection in ZIP file extraction
+- Invalid filename character handling for disk operations
+
+[1.0.0]: https://github.com/yourusername/enex2paperless/releases/tag/v1.0.0

Taskfile.yaml

@@ -74,4 +74,10 @@ tasks:
     desc: Run all tests with verbose output
     dir: .
     cmds:
-      - gotest -v ./...
+      - gotest -count=1 -v ./...
+
+  test:integration:
+    desc: Run integration tests (requires Paperless instance)
+    dir: .
+    cmds:
+      - gotest -count=1 -v -tags=integration ./test/integration/...

cmd/main/main.go

@@ -2,51 +2,72 @@ package main
 
 import (
 	"bufio"
-	"enex2paperless/internal/config"
-	"enex2paperless/internal/logging"
-	"enex2paperless/pkg/enex"
 	"fmt"
 	"log/slog"
 	"os"
 	"path/filepath"
 	"strings"
-	"sync"
+
+	"enex2paperless/internal/config"
+	"enex2paperless/internal/logging"
+	"enex2paperless/pkg/enex"
 
 	"github.com/spf13/cobra"
 )
 
+// CLI flag variables
+var (
+	howMany          int
+	verbose          bool
+	nocolor          bool
+	outputfolder     string
+	tags             []string
+	useFilenameAsTag bool
+)
+
 func main() {
 	// define root command
 	rootCmd := &cobra.Command{
 		Use:   "enex2paperless [file path]",
 		Short: "ENEX to Paperless-NGX parser",
 		Long:  `An ENEX file parser for Paperless-NGX. https://github.com/kevinzehnder/enex2paperless`,
-		Args:  cobra.MinimumNArgs(1),
-		PreRun: func(cmd *cobra.Command, args []string) {
-			// this block will execute after flag parsing and before the main Run
+		Args:  cobra.ExactArgs(1),
+		PreRunE: func(cmd *cobra.Command, args []string) error {
+			// validate concurrent workers
+			if howMany < 1 {
+				return fmt.Errorf("concurrent workers must be at least 1, got %d", howMany)
+			}
+
+			// validate output folder if specified
+			if outputfolder != "" {
+				info, err := os.Stat(outputfolder)
+				if err != nil {
+					if os.IsNotExist(err) {
+						return fmt.Errorf("output folder does not exist: %s", outputfolder)
+					}
+					return fmt.Errorf("cannot access output folder: %w", err)
+				}
+				if !info.IsDir() {
+					return fmt.Errorf("output folder is not a directory: %s", outputfolder)
+				}
+			}
 
-			// configure SLOG with the determined log level from verbose flag
-			verbose, err := cmd.Flags().GetBool("verbose") // Ensure to get the flag value correctly
-			if err != nil {
-				fmt.Println("Error retrieving verbose flag:", err)
-				os.Exit(1)
+			// validate input file exists
+			if _, err := os.Stat(args[0]); err != nil {
+				if os.IsNotExist(err) {
+					return fmt.Errorf("input file does not exist: %s", args[0])
+				}
+				return fmt.Errorf("cannot access input file: %w", err)
 			}
 
-			// set log level
+			// set log level based on verbose flag
 			var logLevel slog.Level
 			if verbose {
 				logLevel = slog.LevelDebug
 			} else {
 				logLevel = slog.LevelInfo
 			}
 
-			// nocolor option
-			nocolor, err := cmd.Flags().GetBool("nocolor")
-			if err != nil {
-				fmt.Println("Error retrieving nocolor flag:", err)
-				os.Exit(1)
-			}
-
 			opts := &slog.HandlerOptions{
 				Level: logLevel,
 			}
@@ -55,76 +76,25 @@ func main() {
 			logger := slog.New(logging.NewHandler(opts, nocolor))
 			slog.SetDefault(logger)
 
-			// handle configuration
-			settings, err := config.GetConfig()
-			if err != nil {
-				slog.Error("configuration error:", "error", err)
-				os.Exit(1)
-			}
-			slog.Debug(fmt.Sprintf("configuration: %v", settings))
-
-			// add to configuration
-			outputfolder, err := cmd.Flags().GetString("outputfolder")
-			if err != nil {
-				fmt.Println("Error retrieving outputfolder flag:", err)
-				os.Exit(1)
-			}
-
-			if outputfolder != "" {
-				config.SetOutputFolder(outputfolder)
-			}
-
-			// Set additional tags if provided
-			tags, err := cmd.Flags().GetStringSlice("tags")
-			if err != nil {
-				fmt.Println("Error retrieving tag flag:", err)
-				os.Exit(1)
-			}
-
-			useFilenameAsTag, err := cmd.Flags().GetBool("use-filename-tag")
-			if err != nil {
-				fmt.Println("Error retrieving tag flag:", err)
-				os.Exit(1)
-			}
-			if useFilenameAsTag {
-				// Extract filename without path and extension
-				baseName := filepath.Base(args[0])
-				tagName := strings.TrimSuffix(baseName, filepath.Ext(baseName))
-				tags = append(tags, tagName)
-			}
-
-			if len(tags) > 0 {
-				config.SetAdditionalTags(tags)
-			}
-
+			return nil
 		},
 
 		// run main function
 		Run: importENEX,
 	}
 
 	// add flags
-	var howMany int
 	rootCmd.PersistentFlags().IntVarP(&howMany, "concurrent", "c", 1, "Number of concurrent consumers")
-
-	var verbose bool
 	rootCmd.PersistentFlags().BoolVarP(&verbose, "verbose", "v", false, "Enable verbose logging")
-
-	var nocolor bool
 	rootCmd.PersistentFlags().BoolVarP(&nocolor, "nocolor", "n", false, "Disable colored output")
-
-	var outputfolder string
 	rootCmd.PersistentFlags().StringVarP(&outputfolder, "outputfolder", "o", "", "Output attachements to this folder, NOT paperless.")
-
-	rootCmd.PersistentFlags().StringSliceP("tags", "t", nil, "Additional tags to add to all documents.")
-
-	var useFilenameAsTag bool
+	rootCmd.PersistentFlags().StringSliceVarP(&tags, "tags", "t", nil, "Additional tags to add to all documents.")
 	rootCmd.PersistentFlags().BoolVarP(&useFilenameAsTag, "use-filename-tag", "T", false, "Add the ENEX filename as tag to all documents.")
 
 	// run root command
 	err := rootCmd.Execute()
 	if err != nil {
-		fmt.Println("Error executing command:", err)
+		// cobra prints error message, we just handle exit code
 		os.Exit(1)
 	}
 }
@@ -133,114 +103,46 @@ func importENEX(cmd *cobra.Command, args []string) {
 	slog.Debug("starting importENEX")
 	settings, _ := config.GetConfig()
 
-	if settings.OutputFolder != "" {
-		slog.Info(fmt.Sprintf("Output to local storage is enabled. Target is: %v", settings.OutputFolder))
+	// Apply flag overrides to config
+	if outputfolder != "" {
+		settings.OutputFolder = outputfolder
 	}
 
-	// determine how many concurrent uploaders we want
-	howMany, err := cmd.Flags().GetInt("concurrent")
-	if err != nil {
-		slog.Error("failed to read flag", "error", err)
-		os.Exit(1)
+	if useFilenameAsTag {
+		baseName := filepath.Base(args[0])
+		tagName := strings.TrimSuffix(baseName, filepath.Ext(baseName))
+		tags = append(tags, tagName)
 	}
-
-	// prepare input file with initialized channels
-	filePath := args[0]
-	inputFile := enex.NewEnexFile(filePath)
-
-	// Failure Catcher
-	var failedNotes []enex.Note
-	go func() {
-		inputFile.FailedNoteCatcher(&failedNotes)
-		inputFile.FailedNoteSignal <- true
-	}()
-
-	// Producer
-	go func() {
-		err := inputFile.ReadFromFile()
-		if err != nil {
-			slog.Error("failed to read from file", "error", err)
-			os.Exit(1)
-		}
-	}()
-
-	// Consumers
-	var wg sync.WaitGroup
-	wg.Add(howMany)
-
-	for i := 0; i < howMany; i++ {
-		go func() {
-			err := inputFile.UploadFromNoteChannel(settings.OutputFolder)
-			if err != nil {
-				slog.Error("failed to upload resources", "error", err)
-				os.Exit(1)
-			}
-
-			wg.Done()
-		}()
+	if len(tags) > 0 {
+		settings.AdditionalTags = tags
 	}
-	slog.Debug("waiting for Consumers (WaitGroup)")
-	wg.Wait()
-
-	// close failedNoteChannel when consumers are done
-	close(inputFile.FailedNoteChannel)
 
-	// wait for FailedNoteCatcher
-	slog.Debug("waiting for FailedNoteCatcher")
-	<-inputFile.FailedNoteSignal
+	if settings.OutputFolder != "" {
+		slog.Info(fmt.Sprintf("Output to local storage is enabled. Target is: %v", settings.OutputFolder))
+	}
 
-	// log results
-	slog.Info("ENEX processing done",
-		slog.Int("numberOfNotes", int(inputFile.NumNotes.Load())),
-		slog.Int("totalFiles", int(inputFile.Uploads.Load())),
-	)
+	// Prepare input file with initialized channels
+	filePath := args[0]
+	inputFile := enex.NewEnexFile(filePath, settings)
+
+	// Process the ENEX file with retry prompts
+	result, err := inputFile.Process(enex.ProcessOptions{
+		ConcurrentWorkers: howMany,
+		OutputFolder:      settings.OutputFolder,
+		RetryPromptFunc: func(failedCount int) bool {
+			// Prompt user whether to retry failed notes
+			slog.Warn("there have been errors, starting retry cycle", "errors", failedCount)
+			PressKeyToContinue()
+			return true
+		},
+	})
 
-	for {
-		// if we still have failedNotes in this iteration, keep going
-		if len(failedNotes) == 0 {
-			break
+	if err != nil {
+		slog.Error("processing completed with errors", "error", err)
+		if len(result.FailedNotes) > 0 {
+			slog.Error("some notes could not be processed", "failedCount", len(result.FailedNotes))
 		}
-
-		slog.Warn("there have been errors, starting retry cycle", "errors", len(failedNotes))
-		PressKeyToContinue()
-
-		// all failed notes are now in failedNotes slice
-		// push notes that failed this Cycle into failedThisCycle slice
-		failedThisCycle := []enex.Note{}
-
-		// Create a fresh EnexFile for the retry - empty file path since we're not reading a file
-		inputFile = enex.NewEnexFile("")
-
-		// this feeds the failedNotes slice into the failedNoteChannel
-		go func() {
-			inputFile.FailedNoteCatcher(&failedThisCycle)
-			inputFile.FailedNoteSignal <- true
-		}()
-
-		// this feeds the failedNotes into the Retry Channel
-		go inputFile.RetryFeeder(&failedNotes)
-
-		// this works on the retry channel
-		wg.Add(1)
-		go func() {
-			err = inputFile.UploadFromNoteChannel(settings.OutputFolder)
-			if err != nil {
-				slog.Error("failed to upload resources", "error", err)
-				os.Exit(1)
-			}
-			wg.Done()
-		}()
-		wg.Wait()
-
-		// when the uploader is done, we can close the failedNoteChannel
-		// to signal to the FailedNote Catcher that it can stop
-		close(inputFile.FailedNoteChannel)
-
-		// then we wait for the FailedNoteCatcher to stop
-		<-inputFile.FailedNoteSignal
-
-		// we move the notes that failed this cycle into the failedNotes variable
-		failedNotes = failedThisCycle
+		os.Exit(1)
 	}
 
 	slog.Info("all notes processed successfully")

cmd/main/main_test.go

@@ -1,13 +1,18 @@
 package main
 
 import (
+	"enex2paperless/internal/config"
 	"enex2paperless/pkg/enex"
 	"sync"
 	"testing"
 
 	"github.com/spf13/afero"
 )
 
+var (
+	testConfig config.Config
+)
+
 type testCase struct {
 	Name          string
 	MockEnexData  string
@@ -108,7 +113,7 @@ func TestReadFromFile(t *testing.T) {
 			afero.WriteFile(mockFs, "test.enex", []byte(tc.MockEnexData), 0644)
 
 			// Create an EnexFile with channels
-			enexFile := enex.NewEnexFile("test.enex")
+			enexFile := enex.NewEnexFile("test.enex", testConfig)
 			enexFile.Fs = mockFs
 
 			// Use a wait group to synchronize test