Fix stream selection flags for bytohgn fork

Merge pull request 'bugfixes' (#12 ) from bugfixes into main
Reviewed-on: #12
2026-04-14 11:07:58 +02:00 · 2026-04-14 10:26:04 +02:00 · 2026-04-14 10:25:53 +02:00 · 2026-04-14 10:21:21 +02:00 · 2026-04-14 10:21:11 +02:00 · 2025-06-01 19:44:24 +02:00
36 changed files with 2960 additions and 960 deletions
--- a/.gitignore
+++ b/.gitignore
@@ -1 +1,7 @@
 config.toml
+drmdtool
+drmdtool_*
+src/DRMDTool
+*.exe
+uploads/
+src/uploads/
--- a/40
+++ b/40
@@ -0,0 +1,40 @@
+GOCMD=go
+GOBUILD=$(GOCMD) build
+GOCLEAN=$(GOCMD) clean
+GOTEST=$(GOCMD) test
+GOGET=$(GOCMD) get
+BINARY_NAME=drmdtool
+SRC_DIR=src
+
+all: test build
+
+build:
+	cd $(SRC_DIR) && $(GOBUILD) -o ../$(BINARY_NAME) -v
+
+test:
+	cd $(SRC_DIR) && $(GOTEST) -v ./...
+
+clean:
+	$(GOCLEAN)
+	rm -f $(BINARY_NAME)
+
+run:
+	cd $(SRC_DIR) && $(GOBUILD) -o ../$(BINARY_NAME) -v
+	./$(BINARY_NAME)
+
+deps:
+	$(GOGET) github.com/BurntSushi/toml
+	$(GOGET) github.com/beevik/etree
+	$(GOGET) github.com/asticode/go-astisub
+
+# Cross compilation
+build-linux:
+	cd $(SRC_DIR) && CGO_ENABLED=0 GOOS=linux GOARCH=amd64 $(GOBUILD) -o ../$(BINARY_NAME)_linux -v
+
+build-windows:
+	cd $(SRC_DIR) && CGO_ENABLED=0 GOOS=windows GOARCH=amd64 $(GOBUILD) -o ../$(BINARY_NAME).exe -v
+
+build-mac:
+	cd $(SRC_DIR) && CGO_ENABLED=0 GOOS=darwin GOARCH=amd64 $(GOBUILD) -o ../$(BINARY_NAME)_mac -v
+
+.PHONY: all build test clean run deps build-linux build-windows build-mac
--- a/README.md
+++ b/README.md
@@ -7,15 +7,76 @@ drmdtool is a utility for processing .drmd files using N_m3u8DL-RE.
 Create a `config.toml` file in the same directory as the drmdtool executable:

 ```toml
+[General]
 BaseDir = "/path/to/save/downloads"
 Format = "mkv"
 TempBaseDir = "/tmp/nre"
+EnableConsole = true
+MaxUploadMB = 32

-[N_m3u8DL-RE]
+[WatchFolder]
+Path = "/path/to/watched/folder"
+PollingInterval = 10
+UsePolling = true
+UseInotify = false
+
+[N_m3u8DLRE]
 Path = "/path/to/N_m3u8DL-RE"
+
+[Server]
+Host = "127.0.0.1"
+Port = 8080
+ReadTimeoutSec = 30
+WriteTimeoutSec = 30
+IdleTimeoutSec = 60
+ReadHeaderTimeoutS = 10
+
+[Security]
+AuthToken = ""
 ```

-Adjust the paths and format as needed. (mkv, mp4)
+### Configuration Options
+
+- **General**
+  - `BaseDir`: Directory where downloaded files will be saved.
+  - `Format`: Output format for the downloaded files (e.g., `mkv`, `mp4`).
+  - `TempBaseDir`: Temporary directory for intermediate files.
+  - `EnableConsole`: Boolean to enable or disable console output.
+  - `MaxUploadMB`: Maximum allowed upload size for the web UI.
+
+- **WatchFolder**
+  - `Path`: Directory to watch for new `.drmd` files.
+  - `PollingInterval`: Interval in seconds for polling the watch folder.
+  - `UsePolling`: Boolean to enable or disable folder polling.
+  - `UseInotify`: Boolean to enable or disable inotify for file watching.
+
+- **N_m3u8DLRE**
+  - `Path`: Path to the N_m3u8DL-RE executable.
+
+- **Server**
+  - `Host`: Bind address for the web server (`127.0.0.1` recommended).
+  - `Port`: Web server port.
+  - `ReadTimeoutSec`, `WriteTimeoutSec`, `IdleTimeoutSec`, `ReadHeaderTimeoutS`: HTTP timeout settings.
+
+- **Security**
+  - `AuthToken`: Optional token for protecting all endpoints. Recommended when binding to a non-loopback host.
+
+### Environment Variable Overrides
+
+You can override the configuration options using environment variables. The following environment variables are supported:
+
+- `BASE_DIR`: Overrides `General.BaseDir`
+- `FORMAT`: Overrides `General.Format`
+- `TEMP_BASE_DIR`: Overrides `General.TempBaseDir`
+- `ENABLE_CONSOLE`: Overrides `General.EnableConsole` (set to `true` or `false`)
+- `MAX_UPLOAD_MB`: Overrides `General.MaxUploadMB`
+- `WATCHED_FOLDER`: Overrides `WatchFolder.Path`
+- `USE_POLLING`: Overrides `WatchFolder.UsePolling` (set to `true` or `false`)
+- `USE_INOTIFY`: Overrides `WatchFolder.UseInotify` (set to `true` or `false`)
+- `POLLING_INTERVAL`: Overrides `WatchFolder.PollingInterval`
+- `SERVER_HOST`: Overrides `Server.Host`
+- `SERVER_PORT`: Overrides `Server.Port`
+- `AUTH_TOKEN`: Overrides `Security.AuthToken`

 ## Web UI Usage

@@ -26,8 +87,10 @@ Adjust the paths and format as needed. (mkv, mp4)

 2. Open a web browser and go to `http://localhost:8080`

-3. Use the interface to upload .drmd files and monitor download progress
+   If `Security.AuthToken` is configured, include it as a query parameter:
+   `http://localhost:8080/?token=YOUR_TOKEN`

+3. Use the interface to upload .drmd files and monitor download progress

 ## CLI Usage

@@ -37,4 +100,18 @@ To process a file directly from the command line:
 ./drmdtool -f /path/to/file.drmd
 ```

-This will download the file and save it in the base directory specified in the config.
+This will download the file and save it in the base directory specified in the config.
+
+# Previews
+
+## Index Page
+
+![Index Page](images/index.png)
+
+## Select Page
+
+![Select Page](images/select.png)
+
+## Progress Page
+
+![Progress Page](images/progress.png)
--- a/config.go
+++ b/config.go
@@ -1,42 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io"
-	"os"
-
-	"github.com/BurntSushi/toml"
-)
-
-type Config struct {
-	BaseDir     string
-	Format      string
-	TempBaseDir string
-	N_m3u8DLRE  struct {
-		Path string
-	}
-}
-
-var config Config
-
-func loadConfig() {
-	configFile, err := os.Open("config.toml")
-	if err != nil {
-		fmt.Println("Error opening config file:", err)
-		return
-	}
-	defer configFile.Close()
-
-	byteValue, _ := io.ReadAll(configFile)
-
-	if _, err := toml.Decode(string(byteValue), &config); err != nil {
-		fmt.Println("Error decoding config file:", err)
-		return
-	}
-
-	if config.N_m3u8DLRE.Path == "" {
-		fmt.Println("Error: N_m3u8DL-RE path is not specified in the config file")
-		return
-	}
-
-}
--- a/config.template.toml
+++ b/config.template.toml
@@ -0,0 +1,26 @@
+[General]
+BaseDir = "/mnt/media"
+Format = "mkv"
+TempBaseDir = "/tmp/nre"
+EnableConsole = true
+MaxUploadMB = 32
+
+[WatchFolder]
+Path = "/mnt/watched"
+PollingInterval = 10
+UsePolling = false 
+UseInotify = false 
+
+[N_m3u8DLRE]
+Path = "nre"
+
+[Server]
+Host = "127.0.0.1"
+Port = 8080
+ReadTimeoutSec = 30
+WriteTimeoutSec = 30
+IdleTimeoutSec = 60
+ReadHeaderTimeoutS = 10
+
+[Security]
+AuthToken = ""
--- a/config.toml
+++ b/config.toml
@@ -1,6 +0,0 @@
-BaseDir = "/mnt/media"
-Format = "mkv" 
-TempBaseDir = "/tmp/nre"
-
-[N_m3u8DLRE]
-Path = "nre"
--- a/downloaders.go
+++ b/downloaders.go
@@ -1,174 +0,0 @@
-package main
-
-import (
-	"encoding/base64"
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"os/exec"
-	"path/filepath"
-	"strings"
-)
-
-func removeBOM(input []byte) []byte {
-	if len(input) >= 3 && input[0] == 0xEF && input[1] == 0xBB && input[2] == 0xBF {
-		return input[3:]
-	}
-	return input
-}
-
-func downloadFile(item Item, jobInfo *JobInfo) error {
-	fmt.Println("Downloading:", item.Filename)
-
-	tempDir := filepath.Join(config.TempBaseDir, sanitizeFilename(item.Filename))
-	err := os.MkdirAll(tempDir, 0755)
-	if err != nil {
-		return fmt.Errorf("error creating temporary directory: %v", err)
-	}
-
-	jobInfo.TempDir = tempDir
-
-	mpdPath := item.MPD
-	if !isValidURL(item.MPD) {
-		decodedMPD, err := base64.StdEncoding.DecodeString(item.MPD)
-		if err != nil {
-			return fmt.Errorf("error decoding base64 MPD: %v", err)
-		}
-
-		tempFile, err := os.CreateTemp("", "temp_mpd_*.mpd")
-		if err != nil {
-			return fmt.Errorf("error creating temporary MPD file: %v", err)
-		}
-		defer os.Remove(tempFile.Name())
-
-		if _, err := tempFile.Write(decodedMPD); err != nil {
-			return fmt.Errorf("error writing to temporary MPD file: %v", err)
-		}
-		if err := tempFile.Close(); err != nil {
-			return fmt.Errorf("error closing temporary MPD file: %v", err)
-		}
-
-		mpdPath = tempFile.Name()
-	} else if strings.HasPrefix(item.MPD, "https://pubads.g.doubleclick.net") {
-		resp, err := http.Get(item.MPD)
-		if err != nil {
-			return fmt.Errorf("error downloading MPD: %v", err)
-		}
-		defer resp.Body.Close()
-
-		mpdContent, err := io.ReadAll(resp.Body)
-		if err != nil {
-			return fmt.Errorf("error reading MPD content: %v", err)
-		}
-
-		fixedMPDContent, err := fixGoPlay(string(mpdContent))
-		if err != nil {
-			return fmt.Errorf("error fixing MPD content: %v", err)
-		}
-
-		tempFile, err := os.CreateTemp("", "fixed_mpd_*.mpd")
-		if err != nil {
-			return fmt.Errorf("error creating temporary MPD file: %v", err)
-		}
-		defer os.Remove(tempFile.Name())
-
-		if _, err := tempFile.WriteString(fixedMPDContent); err != nil {
-			return fmt.Errorf("error writing to temporary MPD file: %v", err)
-		}
-		if err := tempFile.Close(); err != nil {
-			return fmt.Errorf("error closing temporary MPD file: %v", err)
-		}
-
-		mpdPath = tempFile.Name()
-	}
-
-	command := getDownloadCommand(item, mpdPath, tempDir)
-
-	if item.Subtitles != "" {
-		subtitlePaths, err := downloadAndConvertSubtitles(item.Subtitles)
-		if err != nil {
-			fmt.Printf("Error processing subtitles: %v\n", err)
-		} else {
-			for _, path := range subtitlePaths {
-				fmt.Println("Adding subtitle:", path)
-				command += fmt.Sprintf(" --mux-import \"path=%s:lang=nl:name=Nederlands\"", path)
-			}
-		}
-	}
-
-	cmd := exec.Command("bash", "-c", command)
-
-	jobsMutex.Lock()
-	jobInfo.Cmd = cmd
-	jobsMutex.Unlock()
-
-	cmd.Stdout = os.Stdout
-	cmd.Stderr = os.Stderr
-
-	err = cmd.Start()
-	if err != nil {
-		return fmt.Errorf("error starting download command: %v", err)
-	}
-
-	done := make(chan error)
-	go func() {
-		done <- cmd.Wait()
-	}()
-
-	select {
-	case <-jobInfo.AbortChan:
-		if cmd.Process != nil {
-			cmd.Process.Kill()
-		}
-		os.RemoveAll(tempDir)
-		return fmt.Errorf("download aborted")
-	case err := <-done:
-		if jobInfo.Paused {
-			return fmt.Errorf("download paused")
-		}
-		if err != nil {
-			return fmt.Errorf("error executing download command: %v", err)
-		}
-	}
-
-	fmt.Println("Download completed successfully")
-	os.RemoveAll(tempDir)
-	return nil
-}
-
-func getDownloadCommand(item Item, mpdPath string, tempDir string) string {
-	metadata := parseMetadata(item.Metadata)
-	keys := getKeys(item.Keys)
-
-	command := fmt.Sprintf("%s %s", config.N_m3u8DLRE.Path, mpdPath)
-
-	for _, key := range keys {
-		if key != "" {
-			command += fmt.Sprintf(" --key %s", key)
-		}
-	}
-
-	command += " --auto-select"
-
-	sanitizedFilename := sanitizeFilename(item.Filename)
-
-	filename := fmt.Sprintf("\"%s\"", sanitizedFilename)
-	command += fmt.Sprintf(" --save-name %s", filename)
-
-	command += fmt.Sprintf(" --mux-after-done format=%s", config.Format)
-
-	saveDir := config.BaseDir
-	if metadata.Type == "serie" {
-		saveDir = filepath.Join(saveDir, "Series", metadata.Title, metadata.Season)
-	} else {
-		saveDir = filepath.Join(saveDir, "Movies", metadata.Title)
-	}
-	command += fmt.Sprintf(" --save-dir \"%s\"", saveDir)
-
-	command += fmt.Sprintf(" --tmp-dir \"%s\"", tempDir)
-
-	fmt.Println(command)
-
-	return command
-}
--- a/handlers.go
+++ b/handlers.go
@@ -1,353 +0,0 @@
-package main
-
-import (
-	"encoding/json"
-	"fmt"
-	"io"
-	"net/http"
-	"net/url"
-	"os"
-	"path/filepath"
-	"strings"
-)
-
-type ProgressInfo struct {
-	Percentage  float64
-	CurrentFile string
-	Paused      bool
-}
-
-func handleRoot(w http.ResponseWriter, r *http.Request) {
-	progressMutex.Lock()
-	defer progressMutex.Unlock()
-
-	jobsInfo := make(map[string]struct {
-		Percentage  float64
-		CurrentFile string
-		Paused      bool
-	})
-
-	for filename, info := range progress {
-		jobsInfo[filename] = struct {
-			Percentage  float64
-			CurrentFile string
-			Paused      bool
-		}{
-			Percentage:  info.Percentage,
-			CurrentFile: info.CurrentFile,
-			Paused:      info.Paused,
-		}
-	}
-
-	err := templates.ExecuteTemplate(w, "index", struct {
-		Jobs map[string]struct {
-			Percentage  float64
-			CurrentFile string
-			Paused      bool
-		}
-	}{jobsInfo})
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-	}
-}
-
-func handleUpload(w http.ResponseWriter, r *http.Request) {
-	err := r.ParseMultipartForm(32 << 20)
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	files := r.MultipartForm.File["files"]
-	if len(files) == 0 {
-		http.Error(w, "No files uploaded", http.StatusBadRequest)
-		return
-	}
-
-	uploadedFiles := []string{}
-
-	for _, fileHeader := range files {
-		file, err := fileHeader.Open()
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		defer file.Close()
-
-		tempFile, err := os.CreateTemp(uploadDir, fileHeader.Filename)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-		defer tempFile.Close()
-
-		_, err = io.Copy(tempFile, file)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		uploadedFiles = append(uploadedFiles, filepath.Base(tempFile.Name()))
-
-		_, err = parseInputFile(tempFile.Name())
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-	}
-
-	validFiles := []string{}
-	for _, file := range uploadedFiles {
-		if file != "" {
-			validFiles = append(validFiles, file)
-		}
-	}
-
-	if len(validFiles) == 0 {
-		http.Error(w, "No valid files were uploaded", http.StatusBadRequest)
-		return
-	}
-
-	http.Redirect(w, r, "/select?files="+url.QueryEscape(strings.Join(validFiles, ",")), http.StatusSeeOther)
-}
-
-func handleSelect(w http.ResponseWriter, r *http.Request) {
-	filesParam := r.URL.Query().Get("files")
-	filenames := strings.Split(filesParam, ",")
-
-	allItems := make(map[string]map[string][]Item)
-
-	for _, filename := range filenames {
-		if filename == "" {
-			continue
-		}
-		fullPath := filepath.Join(uploadDir, filename)
-
-		if _, err := os.Stat(fullPath); os.IsNotExist(err) {
-			continue
-		}
-
-		items, err := parseInputFile(fullPath)
-		if err != nil {
-			continue
-		}
-
-		groupedItems := groupItemsBySeason(items)
-		allItems[filename] = groupedItems
-	}
-
-	if len(allItems) == 0 {
-		http.Error(w, "No valid files were processed", http.StatusBadRequest)
-		return
-	}
-
-	err := templates.ExecuteTemplate(w, "select", struct {
-		Filenames string
-		AllItems  map[string]map[string][]Item
-	}{
-		Filenames: filesParam,
-		AllItems:  allItems,
-	})
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-	}
-}
-
-func handleProcess(w http.ResponseWriter, r *http.Request) {
-	if err := r.ParseForm(); err != nil {
-		http.Error(w, err.Error(), http.StatusBadRequest)
-		return
-	}
-
-	selectedItems := r.Form["items"]
-	if len(selectedItems) == 0 {
-		http.Error(w, "No items selected", http.StatusBadRequest)
-		return
-	}
-
-	itemsByFile := make(map[string][]string)
-	for _, item := range selectedItems {
-		parts := strings.SplitN(item, ":", 2)
-		if len(parts) != 2 {
-			continue
-		}
-		filename, itemName := parts[0], parts[1]
-		itemsByFile[filename] = append(itemsByFile[filename], itemName)
-	}
-
-	for filename, items := range itemsByFile {
-		fullPath := filepath.Join(uploadDir, filename)
-		allItems, err := parseInputFile(fullPath)
-		if err != nil {
-			http.Error(w, err.Error(), http.StatusInternalServerError)
-			return
-		}
-
-		selectedItems := filterSelectedItems(allItems, items)
-		go processItems(filename, selectedItems)
-	}
-
-	http.Redirect(w, r, "/", http.StatusSeeOther)
-}
-
-func handleProgress(w http.ResponseWriter, r *http.Request) {
-	filename := r.URL.Query().Get("filename")
-
-	if r.Header.Get("Accept") == "application/json" {
-		progressInfo := getProgress(filename)
-
-		if progressInfo == nil {
-			w.WriteHeader(http.StatusNotFound)
-			json.NewEncoder(w).Encode(map[string]string{"error": "No progress information found"})
-			return
-		}
-
-		w.Header().Set("Content-Type", "application/json")
-		err := json.NewEncoder(w).Encode(progressInfo)
-		if err != nil {
-			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
-			return
-		}
-		return
-	}
-
-	err := templates.ExecuteTemplate(w, "progress", struct{ Filename string }{filename})
-	if err != nil {
-		http.Error(w, err.Error(), http.StatusInternalServerError)
-	}
-}
-
-func handlePause(w http.ResponseWriter, r *http.Request) {
-	filename := r.URL.Query().Get("filename")
-	if filename == "" {
-		http.Error(w, "Filename is required", http.StatusBadRequest)
-		return
-	}
-
-	jobsMutex.Lock()
-	jobInfo, exists := jobs[filename]
-	jobsMutex.Unlock()
-
-	if !exists {
-		http.Error(w, "Job not found", http.StatusNotFound)
-		return
-	}
-
-	jobInfo.Paused = true
-	if jobInfo.Cmd != nil && jobInfo.Cmd.Process != nil {
-		jobInfo.Cmd.Process.Kill()
-	}
-
-	progressMutex.Lock()
-	if progressInfo, ok := progress[filename]; ok {
-		progressInfo.Paused = true
-	}
-	progressMutex.Unlock()
-
-	fmt.Fprintf(w, "Pause signal sent for %s", filename)
-}
-
-func handleResume(w http.ResponseWriter, r *http.Request) {
-	filename := r.URL.Query().Get("filename")
-	if filename == "" {
-		http.Error(w, "Filename is required", http.StatusBadRequest)
-		return
-	}
-
-	jobsMutex.Lock()
-	jobInfo, exists := jobs[filename]
-	jobsMutex.Unlock()
-
-	if !exists {
-		http.Error(w, "Job not found", http.StatusNotFound)
-		return
-	}
-
-	jobInfo.Paused = false
-	jobInfo.ResumeChan <- struct{}{}
-
-	progressMutex.Lock()
-	if progressInfo, ok := progress[filename]; ok {
-		progressInfo.Paused = false
-	}
-	progressMutex.Unlock()
-
-	fmt.Fprintf(w, "Resume signal sent for %s", filename)
-}
-
-func handleAbort(w http.ResponseWriter, r *http.Request) {
-	filename := r.URL.Query().Get("filename")
-	if filename == "" {
-		http.Error(w, "Filename is required", http.StatusBadRequest)
-		return
-	}
-
-	jobsMutex.Lock()
-	jobInfo, exists := jobs[filename]
-	jobsMutex.Unlock()
-
-	if !exists {
-		http.Error(w, "Job not found", http.StatusNotFound)
-		return
-	}
-
-	close(jobInfo.AbortChan)
-	if jobInfo.Cmd != nil && jobInfo.Cmd.Process != nil {
-		jobInfo.Cmd.Process.Kill()
-	}
-
-	if jobInfo.TempDir != "" {
-		os.RemoveAll(jobInfo.TempDir)
-	}
-
-	fmt.Fprintf(w, "Abort signal sent for %s", filename)
-}
-
-func handleClearCompleted(w http.ResponseWriter, r *http.Request) {
-	if r.Method != http.MethodPost {
-		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
-		return
-	}
-
-	clearCompletedJobs()
-
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(map[string]bool{"success": true})
-}
-
-func clearCompletedJobs() {
-	progressMutex.Lock()
-	defer progressMutex.Unlock()
-
-	for filename, info := range progress {
-		if info.Percentage >= 100 {
-			delete(progress, filename)
-		}
-	}
-}
-
-func updateProgress(filename string, value float64, currentFile string) {
-	progressMutex.Lock()
-	defer progressMutex.Unlock()
-
-	jobsMutex.Lock()
-	jobInfo, exists := jobs[filename]
-	jobsMutex.Unlock()
-
-	paused := false
-	if exists {
-		paused = jobInfo.Paused
-	}
-
-	if existingProgress, ok := progress[filename]; ok {
-		existingProgress.Percentage = value
-		existingProgress.CurrentFile = currentFile
-		existingProgress.Paused = paused
-	} else {
-		progress[filename] = &ProgressInfo{
-			Percentage:  value,
-			CurrentFile: currentFile,
-			Paused:      paused,
-		}
-	}
-}
--- a/images/index.png
+++ b/images/index.png
--- a/images/progress.png
+++ b/images/progress.png
--- a/images/select.png
+++ b/images/select.png
--- a/main.go
+++ b/main.go
@@ -1,105 +0,0 @@
-package main
-
-import (
-	"flag"
-	"fmt"
-	"html/template"
-	"net/http"
-	"os"
-	"strings"
-	"sync"
-
-	"embed"
-)
-
-type Item struct {
-	MPD         string
-	Keys        string
-	Filename    string
-	Description string
-	Subtitles   string
-	Poster      string
-	Metadata    string
-}
-
-type Items struct {
-	Items []Item
-}
-
-type Metadata struct {
-	Title  string
-	Type   string
-	Season string
-}
-
-var progressMutex sync.Mutex
-var progress = make(map[string]*ProgressInfo)
-
-const uploadDir = "uploads"
-
-var templates *template.Template
-
-//go:embed templates
-var templateFS embed.FS
-
-func init() {
-	if err := os.MkdirAll(uploadDir, 0755); err != nil {
-		fmt.Printf("Error creating upload directory: %v\n", err)
-	}
-
-	templates = template.Must(template.ParseFS(templateFS, "templates/*"))
-}
-
-func main() {
-	loadConfig()
-	inputFile := flag.String("f", "", "Path to the input JSON file")
-	flag.Parse()
-
-	if *inputFile == "" {
-		startWebServer()
-	} else {
-		items, err := parseInputFile(*inputFile)
-		if err != nil {
-			fmt.Printf("Error parsing input file: %v\n", err)
-			return
-		}
-		processItems(*inputFile, items)
-	}
-}
-
-func startWebServer() {
-	http.HandleFunc("/", handleRoot)
-	http.HandleFunc("/upload", handleUpload)
-	http.HandleFunc("/select", handleSelect)
-	http.HandleFunc("/process", handleProcess)
-	http.HandleFunc("/progress", handleProgress)
-	http.HandleFunc("/abort", handleAbort)
-	http.HandleFunc("/pause", handlePause)
-	http.HandleFunc("/resume", handleResume)
-	http.HandleFunc("/clear-completed", handleClearCompleted)
-
-	fmt.Println("Starting web server on http://0.0.0.0:8080")
-	http.ListenAndServe(":8080", nil)
-}
-
-func getProgress(filename string) *ProgressInfo {
-	progressMutex.Lock()
-	defer progressMutex.Unlock()
-	return progress[filename]
-}
-
-func getKeys(keys string) []string {
-	return strings.Split(keys, ",")
-}
-
-func parseMetadata(metadata string) Metadata {
-	parts := strings.Split(metadata, ";")
-	if len(parts) != 3 {
-		return Metadata{}
-	}
-	return Metadata{
-		Title:  strings.TrimSpace(parts[0]),
-		Type:   strings.TrimSpace(parts[1]),
-		Season: "S" + strings.TrimSpace(parts[2]),
-	}
-}
--- a/src/config.go
+++ b/src/config.go
@@ -0,0 +1,250 @@
+package main
+
+import (
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"strconv"
+	"strings"
+
+	"github.com/BurntSushi/toml"
+)
+
+type Config struct {
+	General struct {
+		BaseDir       string
+		Format        string
+		TempBaseDir   string
+		EnableConsole bool
+		MaxUploadMB   int
+	}
+	WatchFolder struct {
+		Path            string
+		UsePolling      bool
+		UseInotify      bool
+		PollingInterval int
+	}
+	Server struct {
+		Host               string
+		Port               int
+		ReadTimeoutSec     int
+		WriteTimeoutSec    int
+		IdleTimeoutSec     int
+		ReadHeaderTimeoutS int
+	}
+	Security struct {
+		AuthToken string
+	}
+	N_m3u8DLRE struct {
+		Path string
+	}
+}
+
+var config Config
+
+func loadConfig(path string) {
+	configFile, err := os.Open(path)
+	if err != nil {
+		logger.LogError("Config", fmt.Sprintf("Error opening config file: %v", err))
+		os.Exit(1)
+	}
+	defer configFile.Close()
+
+	byteValue, err := io.ReadAll(configFile)
+	if err != nil {
+		logger.LogError("Config", fmt.Sprintf("Error reading config file: %v", err))
+		os.Exit(1)
+	}
+
+	if _, err := toml.Decode(string(byteValue), &config); err != nil {
+		logger.LogError("Config", fmt.Sprintf("Error decoding config file: %v", err))
+		os.Exit(1)
+	}
+
+	overrideConfigWithEnv()
+	setDefaultConfigValues()
+
+	if err := validatePaths(); err != nil {
+		logger.LogError("Config", fmt.Sprintf("Configuration error: %v", err))
+		os.Exit(1)
+	}
+
+	if config.WatchFolder.PollingInterval <= 0 {
+		config.WatchFolder.PollingInterval = 10
+	}
+
+	logConfig()
+}
+
+func setDefaultConfigValues() {
+	if config.General.MaxUploadMB <= 0 {
+		config.General.MaxUploadMB = 32
+	}
+
+	if strings.TrimSpace(config.Server.Host) == "" {
+		config.Server.Host = "127.0.0.1"
+	}
+
+	if config.Server.Port <= 0 {
+		config.Server.Port = 8080
+	}
+
+	if config.Server.ReadTimeoutSec <= 0 {
+		config.Server.ReadTimeoutSec = 30
+	}
+
+	if config.Server.WriteTimeoutSec <= 0 {
+		config.Server.WriteTimeoutSec = 30
+	}
+
+	if config.Server.IdleTimeoutSec <= 0 {
+		config.Server.IdleTimeoutSec = 60
+	}
+
+	if config.Server.ReadHeaderTimeoutS <= 0 {
+		config.Server.ReadHeaderTimeoutS = 10
+	}
+}
+
+func overrideConfigWithEnv() {
+	if envBaseDir := os.Getenv("BASE_DIR"); envBaseDir != "" {
+		config.General.BaseDir = envBaseDir
+	}
+	if envFormat := os.Getenv("FORMAT"); envFormat != "" {
+		config.General.Format = envFormat
+	}
+	if envTempBaseDir := os.Getenv("TEMP_BASE_DIR"); envTempBaseDir != "" {
+		config.General.TempBaseDir = envTempBaseDir
+	}
+	if envEnableConsole := os.Getenv("ENABLE_CONSOLE"); envEnableConsole != "" {
+		config.General.EnableConsole = strings.ToLower(envEnableConsole) == "true"
+	}
+	if envWatchedFolder := os.Getenv("WATCHED_FOLDER"); envWatchedFolder != "" {
+		config.WatchFolder.Path = envWatchedFolder
+	}
+	if envUsePolling := os.Getenv("USE_POLLING"); envUsePolling != "" {
+		config.WatchFolder.UsePolling = strings.ToLower(envUsePolling) == "true"
+	}
+	if envUseInotify := os.Getenv("USE_INOTIFY"); envUseInotify != "" {
+		config.WatchFolder.UseInotify = strings.ToLower(envUseInotify) == "true"
+	}
+	if envPollingInterval := os.Getenv("POLLING_INTERVAL"); envPollingInterval != "" {
+		if interval, err := strconv.Atoi(envPollingInterval); err == nil {
+			config.WatchFolder.PollingInterval = interval
+		}
+	}
+	if envMaxUploadMB := os.Getenv("MAX_UPLOAD_MB"); envMaxUploadMB != "" {
+		if value, err := strconv.Atoi(envMaxUploadMB); err == nil {
+			config.General.MaxUploadMB = value
+		}
+	}
+	if envHost := os.Getenv("SERVER_HOST"); envHost != "" {
+		config.Server.Host = envHost
+	}
+	if envPort := os.Getenv("SERVER_PORT"); envPort != "" {
+		if value, err := strconv.Atoi(envPort); err == nil {
+			config.Server.Port = value
+		}
+	}
+	if envAuthToken := os.Getenv("AUTH_TOKEN"); envAuthToken != "" {
+		config.Security.AuthToken = envAuthToken
+	}
+}
+
+func validatePaths() error {
+	if strings.TrimSpace(config.General.Format) == "" {
+		return errors.New("format is not specified")
+	}
+
+	allowedFormats := map[string]bool{"mkv": true, "mp4": true}
+	if !allowedFormats[strings.ToLower(config.General.Format)] {
+		return fmt.Errorf("unsupported format: %s (supported: mkv, mp4)", config.General.Format)
+	}
+
+	paths := []struct {
+		name string
+		path string
+	}{
+		{"BaseDir", config.General.BaseDir},
+		{"TempBaseDir", config.General.TempBaseDir},
+	}
+
+	for _, p := range paths {
+		if p.path == "" {
+			return fmt.Errorf("%s is not specified", p.name)
+		}
+		if _, err := os.Stat(p.path); os.IsNotExist(err) {
+			if p.name == "TempBaseDir" {
+				if mkErr := os.MkdirAll(p.path, 0755); mkErr != nil {
+					return fmt.Errorf("unable to create %s: %v", p.name, mkErr)
+				}
+				continue
+			}
+			return fmt.Errorf("%s does not exist: %s", p.name, p.path)
+		} else if err != nil {
+			return fmt.Errorf("error accessing %s: %v", p.name, err)
+		}
+	}
+
+	if config.WatchFolder.UsePolling || config.WatchFolder.UseInotify {
+		if config.WatchFolder.Path == "" {
+			return fmt.Errorf("WatchedFolder is not specified")
+		}
+		if _, err := os.Stat(config.WatchFolder.Path); os.IsNotExist(err) {
+			return fmt.Errorf("WatchedFolder does not exist: %s", config.WatchFolder.Path)
+		} else if err != nil {
+			return fmt.Errorf("error accessing WatchedFolder: %v", err)
+		}
+	}
+
+	if strings.TrimSpace(config.N_m3u8DLRE.Path) == "" {
+		return errors.New("N_m3u8DLRE path is not specified")
+	}
+
+	if _, err := exec.LookPath(config.N_m3u8DLRE.Path); err != nil {
+		return fmt.Errorf("N_m3u8DLRE executable not found in PATH: %s", config.N_m3u8DLRE.Path)
+	}
+
+	if config.Server.Port <= 0 || config.Server.Port > 65535 {
+		return fmt.Errorf("invalid server port: %d", config.Server.Port)
+	}
+
+	return nil
+}
+
+func logConfig() {
+	configInfo := fmt.Sprintf(`
+Configuration Loaded:
+  General:
+    BaseDir: %s
+    Format: %s
+    TempBaseDir: %s
+    EnableConsole: %t
+    MaxUploadMB: %d
+  WatchFolder:
+    Path: %s
+    UsePolling: %t
+    UseInotify: %t
+    PollingInterval: %d
+  Server:
+    Host: %s
+    Port: %d
+    ReadTimeoutSec: %d
+    WriteTimeoutSec: %d
+    IdleTimeoutSec: %d
+    ReadHeaderTimeoutS: %d
+  Security:
+    AuthTokenConfigured: %t
+  N_m3u8DLRE:
+    Path: %s
+`, config.General.BaseDir, config.General.Format, config.General.TempBaseDir, config.General.EnableConsole,
+		config.General.MaxUploadMB,
+		config.WatchFolder.Path, config.WatchFolder.UsePolling, config.WatchFolder.UseInotify, config.WatchFolder.PollingInterval,
+		config.Server.Host, config.Server.Port, config.Server.ReadTimeoutSec, config.Server.WriteTimeoutSec, config.Server.IdleTimeoutSec, config.Server.ReadHeaderTimeoutS,
+		strings.TrimSpace(config.Security.AuthToken) != "",
+		config.N_m3u8DLRE.Path)
+
+	logger.LogInfo("Config", configInfo)
+}
--- a/src/downloaders.go
+++ b/src/downloaders.go
@@ -0,0 +1,216 @@
+package main
+
+import (
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"os"
+	"os/exec"
+	"path/filepath"
+	"regexp"
+	"strings"
+)
+
+var decryptionKeyRegex = regexp.MustCompile(`^[0-9a-fA-F]{32}:[0-9a-fA-F]{32}$`)
+
+type websocketBroadcastWriter struct {
+	filename string
+}
+
+func (w websocketBroadcastWriter) Write(p []byte) (int, error) {
+	if config.General.EnableConsole && len(p) > 0 {
+		message := append([]byte(nil), p...)
+		broadcast(w.filename, message)
+	}
+	return len(p), nil
+}
+
+func removeBOM(input []byte) []byte {
+	if len(input) >= 3 && input[0] == 0xEF && input[1] == 0xBB && input[2] == 0xBF {
+		return input[3:]
+	}
+	return input
+}
+
+func downloadFile(drmdFilename string, item Item, jobInfo *JobInfo) error {
+	logger.LogInfo("Download File", fmt.Sprintf("Starting download for: %s", item.Filename))
+
+	if err := os.MkdirAll(config.General.TempBaseDir, 0755); err != nil {
+		logger.LogError("Download File", fmt.Sprintf("Error creating temp base dir: %v", err))
+		return fmt.Errorf("error creating temp base dir: %v", err)
+	}
+	tempDir, err := os.MkdirTemp(config.General.TempBaseDir, sanitizeFilename(item.Filename)+"_")
+	if err != nil {
+		logger.LogError("Download File", fmt.Sprintf("Error creating temporary directory: %v", err))
+		return fmt.Errorf("error creating temporary directory: %v", err)
+	}
+
+	jobInfo.SetTempDir(tempDir)
+
+	mpdPath := item.MPD
+	if !isValidURL(item.MPD) {
+		decodedMPD, err := base64.StdEncoding.DecodeString(item.MPD)
+		if err != nil {
+			logger.LogError("Download File", fmt.Sprintf("Error decoding base64 MPD: %v", err))
+			return fmt.Errorf("error decoding base64 MPD: %v", err)
+		}
+
+		tempFile, err := os.CreateTemp("", "temp_mpd_*.mpd")
+		if err != nil {
+			logger.LogError("Download File", fmt.Sprintf("Error creating temporary MPD file: %v", err))
+			return fmt.Errorf("error creating temporary MPD file: %v", err)
+		}
+		defer os.Remove(tempFile.Name())
+
+		if _, err := tempFile.Write(decodedMPD); err != nil {
+			logger.LogError("Download File", fmt.Sprintf("Error writing to temporary MPD file: %v", err))
+			return fmt.Errorf("error writing to temporary MPD file: %v", err)
+		}
+		if err := tempFile.Close(); err != nil {
+			logger.LogError("Download File", fmt.Sprintf("Error closing temporary MPD file: %v", err))
+			return fmt.Errorf("error closing temporary MPD file: %v", err)
+		}
+
+		mpdPath = tempFile.Name()
+	} else if strings.HasPrefix(item.MPD, "https://pubads.g.doubleclick.net") {
+		mpdContent, err := fetchRemoteContent(item.MPD)
+		if err != nil {
+			logger.LogError("Download File", fmt.Sprintf("Error downloading MPD: %v", err))
+			return fmt.Errorf("error downloading MPD: %v", err)
+		}
+
+		fixedMPDContent, err := fixGoPlay(string(mpdContent))
+		if err != nil {
+			logger.LogError("Download File", fmt.Sprintf("Error fixing MPD content: %v", err))
+			return fmt.Errorf("error fixing MPD content: %v", err)
+		}
+
+		tempFile, err := os.CreateTemp("", "fixed_mpd_*.mpd")
+		if err != nil {
+			logger.LogError("Download File", fmt.Sprintf("Error creating temporary MPD file: %v", err))
+			return fmt.Errorf("error creating temporary MPD file: %v", err)
+		}
+		defer os.Remove(tempFile.Name())
+
+		if _, err := tempFile.WriteString(fixedMPDContent); err != nil {
+			logger.LogError("Download File", fmt.Sprintf("Error writing to temporary MPD file: %v", err))
+			return fmt.Errorf("error writing to temporary MPD file: %v", err)
+		}
+		if err := tempFile.Close(); err != nil {
+			logger.LogError("Download File", fmt.Sprintf("Error closing temporary MPD file: %v", err))
+			return fmt.Errorf("error closing temporary MPD file: %v", err)
+		}
+
+		mpdPath = tempFile.Name()
+	}
+
+	args, err := getDownloadArgs(item, mpdPath, tempDir)
+	if err != nil {
+		return err
+	}
+
+	if item.Subtitles != "" {
+		subtitlePaths, err := downloadAndConvertSubtitles(item.Subtitles)
+		if err != nil {
+			logger.LogError("Download File", fmt.Sprintf("Error processing subtitles: %v", err))
+		} else {
+			for _, path := range subtitlePaths {
+				logger.LogInfo("Download File", fmt.Sprintf("Adding subtitle: %s", path))
+				args = append(args, "--mux-import", fmt.Sprintf("path=%s:lang=nl:name=Nederlands", path))
+			}
+		}
+	}
+
+	cmd := exec.Command(config.N_m3u8DLRE.Path, args...)
+	jobInfo.SetCmd(cmd)
+
+	broadcastWriter := websocketBroadcastWriter{filename: drmdFilename}
+	cmd.Stdout = io.MultiWriter(os.Stdout, broadcastWriter)
+	cmd.Stderr = io.MultiWriter(os.Stderr, broadcastWriter)
+
+	err = cmd.Start()
+	if err != nil {
+		logger.LogError("Download File", fmt.Sprintf("Error starting download command: %v", err))
+		return fmt.Errorf("error starting download command: %v", err)
+	}
+
+	done := make(chan error)
+	go func() {
+		done <- cmd.Wait()
+	}()
+
+	select {
+	case <-jobInfo.AbortChan:
+		jobInfo.KillProcess()
+		_ = os.RemoveAll(tempDir)
+		logger.LogInfo("Download File", "Download aborted")
+		return ErrDownloadAborted
+	case err := <-done:
+		if jobInfo.IsPaused() {
+			logger.LogInfo("Download File", "Download paused")
+			return ErrDownloadPaused
+		}
+		if err != nil {
+			if jobInfo.IsAborted() {
+				return ErrDownloadAborted
+			}
+
+			if jobInfo.IsPaused() {
+				return ErrDownloadPaused
+			}
+
+			logger.LogError("Download File", fmt.Sprintf("Error executing download command: %v", err))
+			return fmt.Errorf("error executing download command: %v", err)
+		}
+	}
+
+	logger.LogInfo("Download File", "Download completed successfully")
+	return nil
+}
+
+func getDownloadArgs(item Item, mpdPath string, tempDir string) ([]string, error) {
+	metadata := parseMetadata(item.Metadata)
+	keys := getKeys(item.Keys)
+
+	args := []string{mpdPath}
+
+	for _, key := range keys {
+		if !decryptionKeyRegex.MatchString(key) {
+			return nil, fmt.Errorf("invalid decryption key format")
+		}
+		args = append(args, "--key", key)
+	}
+
+	args = append(args,
+		"--select-video", "best",
+		"--select-audio", "all",
+		"--select-subtitle", "all",
+	)
+
+	sanitizedFilename := sanitizeFilename(item.Filename)
+	args = append(args, "--save-name", sanitizedFilename)
+	args = append(args, "--mux-after-done", fmt.Sprintf("format=%s", config.General.Format))
+
+	saveDir := config.General.BaseDir
+	if metadata.Type == "serie" {
+		saveDir = filepath.Join(saveDir, "Series", metadata.Title, metadata.Season)
+	} else {
+		saveDir = filepath.Join(saveDir, "Movies", metadata.Title)
+	}
+	if err := os.MkdirAll(saveDir, 0755); err != nil {
+		return nil, fmt.Errorf("unable to create save directory: %w", err)
+	}
+	args = append(args, "--save-dir", saveDir)
+	args = append(args, "--tmp-dir", tempDir)
+
+	currentSpeedLimit := getGlobalSpeedLimit()
+	if currentSpeedLimit != "" {
+		if !speedLimitRegex.MatchString(currentSpeedLimit) {
+			return nil, errors.New("invalid speed limit format")
+		}
+		args = append(args, "-R", currentSpeedLimit)
+	}
+
+	return args, nil
+}
--- a/src/go.mod
+++ b/src/go.mod
@@ -1,6 +1,6 @@
 module DRMDTool

-go 1.23.0
+go 1.25.0

 require (
 	github.com/BurntSushi/toml v1.4.0
@@ -8,9 +8,13 @@ require (
 	github.com/beevik/etree v1.4.1
 )

+require golang.org/x/sys v0.43.0 // indirect
+
 require (
 	github.com/asticode/go-astikit v0.20.0 // indirect
 	github.com/asticode/go-astits v1.8.0 // indirect
-	golang.org/x/net v0.0.0-20200904194848-62affa334b73 // indirect
-	golang.org/x/text v0.3.2 // indirect
+	github.com/fsnotify/fsnotify v1.7.0
+	github.com/gorilla/websocket v1.5.3
+	golang.org/x/net v0.53.0 // indirect
+	golang.org/x/text v0.36.0 // indirect
 )
--- a/src/go.sum
+++ b/src/go.sum
@@ -10,8 +10,10 @@ github.com/beevik/etree v1.4.1 h1:PmQJDDYahBGNKDcpdX8uPy1xRCwoCGVUiW669MEirVI=
 github.com/beevik/etree v1.4.1/go.mod h1:gPNJNaBGVZ9AwsidazFZyygnd+0pAU38N4D+WemwKNs=
 github.com/davecgh/go-spew v1.1.0 h1:ZDRjVQ15GmhC3fiQ8ni8+OwkZQO4DARzQgrnXU1Liz8=
 github.com/davecgh/go-spew v1.1.0/go.mod h1:J7Y8YcW2NihsgmVo/mv3lAwl/skON4iLHjSsI+c5H38=
-github.com/pkg/exec v0.0.0-20150614095509-0bd164ad2a5a h1:EN123kAtAAE2pg/+TvBsUBZfHCWNNFyL2ZBPPfNWAc0=
-github.com/pkg/exec v0.0.0-20150614095509-0bd164ad2a5a/go.mod h1:b95YoNrAnScjaWG+asr8lxqlrsPUcT2ZEBcjvVGshMo=
+github.com/fsnotify/fsnotify v1.7.0 h1:8JEhPFa5W2WU7YfeZzPNqzMP6Lwt7L2715Ggo0nosvA=
+github.com/fsnotify/fsnotify v1.7.0/go.mod h1:40Bi/Hjc2AVfZrqy+aj+yEI+/bRxZnMJyTJwOpGvigM=
+github.com/gorilla/websocket v1.5.3 h1:saDtZ6Pbx/0u+bgYQ3q96pZgCzfhKXGPqt7kZ72aNNg=
+github.com/gorilla/websocket v1.5.3/go.mod h1:YR8l580nyteQvAITg2hZ9XVh4b55+EU/adAjf1fMHhE=
 github.com/pkg/profile v1.4.0/go.mod h1:NWz/XGvpEW1FyYQ7fCx4dqYBLlfTcE+A9FLAkNKqjFE=
 github.com/pmezard/go-difflib v1.0.0 h1:4DBwDE0NGyQoBHbLQYPwSUPoCMWR5BEzIk/f1lZbAQM=
 github.com/pmezard/go-difflib v1.0.0/go.mod h1:iKH77koFhYxTK1pcRnkKkqfTogsbg7gZNVY4sRDYZ/4=
@@ -21,14 +23,18 @@ github.com/stretchr/testify v1.4.0/go.mod h1:j7eGeouHqKxXV5pUuKE4zz7dFj8WfuZ+81P
 golang.org/x/crypto v0.0.0-20190308221718-c2843e01d9a2/go.mod h1:djNgcEr1/C05ACkg1iLfiJU5Ep61QUkGW8qpdssI0+w=
 golang.org/x/crypto v0.0.0-20200622213623-75b288015ac9/go.mod h1:LzIPMQfyMNhhGPhUkYOs5KpL4U8rLKemX1yGLhDgUto=
 golang.org/x/net v0.0.0-20190404232315-eb5bcb51f2a3/go.mod h1:t9HGtf8HONx5eT2rtn7q6eTqICYqUVnKs3thJo3Qplg=
-golang.org/x/net v0.0.0-20200904194848-62affa334b73 h1:MXfv8rhZWmFeqX3GNZRsd6vOLoaCHjYEX3qkRo3YBUA=
 golang.org/x/net v0.0.0-20200904194848-62affa334b73/go.mod h1:/O7V0waA8r7cgGh81Ro3o1hOxt32SMVPicZroKQ2sZA=
+golang.org/x/net v0.53.0 h1:d+qAbo5L0orcWAr0a9JweQpjXF19LMXJE8Ey7hwOdUA=
+golang.org/x/net v0.53.0/go.mod h1:JvMuJH7rrdiCfbeHoo3fCQU24Lf5JJwT9W3sJFulfgs=
 golang.org/x/sys v0.0.0-20190215142949-d0b11bdaac8a/go.mod h1:STP8DvDyc/dI5b8T5hshtkjS+E42TnysNCUPdjciGhY=
 golang.org/x/sys v0.0.0-20190412213103-97732733099d/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
 golang.org/x/sys v0.0.0-20200323222414-85ca7c5b95cd/go.mod h1:h1NjWce9XRLGQEsW7wpKNCjG9DtNlClVuFLEZdDNbEs=
+golang.org/x/sys v0.43.0 h1:Rlag2XtaFTxp19wS8MXlJwTvoh8ArU6ezoyFsMyCTNI=
+golang.org/x/sys v0.43.0/go.mod h1:4GL1E5IUh+htKOUEOaiffhrAeqysfVGipDYzABqnCmw=
 golang.org/x/text v0.3.0/go.mod h1:NqM8EUOU14njkJ3fqMW+pc6Ldnwhi/IjpwHt7yyuwOQ=
-golang.org/x/text v0.3.2 h1:tW2bmiBqwgJj/UpqtC8EpXEZVYOwU0yG4iWbprSVAcs=
 golang.org/x/text v0.3.2/go.mod h1:bEr9sfX3Q8Zfm5fL9x+3itogRgK3+ptLWKqgva+5dAk=
+golang.org/x/text v0.36.0 h1:JfKh3XmcRPqZPKevfXVpI1wXPTqbkE5f7JA92a55Yxg=
+golang.org/x/text v0.36.0/go.mod h1:NIdBknypM8iqVmPiuco0Dh6P5Jcdk8lJL0CUebqK164=
 golang.org/x/tools v0.0.0-20180917221912-90fa682c2a6e/go.mod h1:n7NCudcB/nEzxVGmLbDWY5pfWTLqBcC2KZ6jyYvM4mQ=
 gopkg.in/check.v1 v0.0.0-20161208181325-20d25e280405/go.mod h1:Co6ibVJAznAaIkqp8huTwlJQCZ016jof/cbN4VW5Yz0=
 gopkg.in/yaml.v2 v2.2.2 h1:ZCJp+EgiOT7lHqUV2J862kp8Qj64Jo6az82+3Td9dZw=
--- a/src/handlers_common.go
+++ b/src/handlers_common.go
@@ -0,0 +1,30 @@
+package main
+
+import (
+	"net/url"
+	"regexp"
+	"strings"
+)
+
+type ProgressInfo struct {
+	Percentage  float64
+	CurrentFile string
+	Paused      bool
+	Status      string
+}
+
+var speedLimitRegex = regexp.MustCompile(`^([1-9]\d*(\.\d+)?)(KBps|MBps|GBps)$`)
+
+func withToken(path string) string {
+	token := strings.TrimSpace(config.Security.AuthToken)
+	if token == "" {
+		return path
+	}
+
+	separator := "?"
+	if strings.Contains(path, "?") {
+		separator = "&"
+	}
+
+	return path + separator + "token=" + url.QueryEscape(token)
+}
--- a/src/handlers_jobs.go
+++ b/src/handlers_jobs.go
@@ -0,0 +1,174 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"os"
+	"strings"
+)
+
+func handlePause(w http.ResponseWriter, r *http.Request) {
+	if !ensureMethod(w, r, http.MethodPost) || !ensureAuthorized(w, r) {
+		return
+	}
+
+	filename := r.URL.Query().Get("filename")
+	if filename == "" {
+		logger.LogError("Pause Handler", "Filename is required")
+		http.Error(w, "Filename is required", http.StatusBadRequest)
+		return
+	}
+
+	jobInfo, exists := getJob(filename)
+	if !exists {
+		logger.LogError("Pause Handler", "Job not found")
+		http.Error(w, "Job not found", http.StatusNotFound)
+		return
+	}
+
+	jobInfo.SetPaused(true)
+	logger.LogJobState(filename, "pausing")
+	jobInfo.KillProcess()
+
+	paused := true
+	setProgressStatus(filename, &paused, "paused")
+
+	_, _ = fmt.Fprintf(w, "Pause signal sent for %s", filename)
+}
+
+func handleResume(w http.ResponseWriter, r *http.Request) {
+	if !ensureMethod(w, r, http.MethodPost) || !ensureAuthorized(w, r) {
+		return
+	}
+
+	filename := r.URL.Query().Get("filename")
+	if filename == "" {
+		http.Error(w, "Filename is required", http.StatusBadRequest)
+		return
+	}
+
+	jobInfo, exists := getJob(filename)
+	if !exists {
+		http.Error(w, "Job not found", http.StatusNotFound)
+		return
+	}
+
+	jobInfo.SetPaused(false)
+	jobInfo.SignalResume()
+
+	paused := false
+	setProgressStatus(filename, &paused, "running")
+
+	_, _ = fmt.Fprintf(w, "Resume signal sent for %s", filename)
+}
+
+func handleAbort(w http.ResponseWriter, r *http.Request) {
+	if !ensureMethod(w, r, http.MethodPost) || !ensureAuthorized(w, r) {
+		return
+	}
+
+	filename := r.URL.Query().Get("filename")
+	if filename == "" {
+		http.Error(w, "Filename is required", http.StatusBadRequest)
+		return
+	}
+
+	jobInfo, exists := getJob(filename)
+	if !exists {
+		http.Error(w, "Job not found", http.StatusNotFound)
+		return
+	}
+
+	jobInfo.Abort()
+	jobInfo.KillProcess()
+
+	if tempDir := jobInfo.GetTempDir(); tempDir != "" {
+		_ = os.RemoveAll(tempDir)
+	}
+
+	paused := false
+	setProgressStatus(filename, &paused, "aborted")
+
+	_, _ = fmt.Fprintf(w, "Abort signal sent for %s", filename)
+}
+
+func handleClearCompleted(w http.ResponseWriter, r *http.Request) {
+	if !ensureMethod(w, r, http.MethodPost) || !ensureAuthorized(w, r) {
+		return
+	}
+
+	clearCompletedJobs()
+
+	w.Header().Set("Content-Type", "application/json")
+	_ = json.NewEncoder(w).Encode(map[string]bool{"success": true})
+}
+
+func clearCompletedJobs() {
+	progressMutex.Lock()
+	defer progressMutex.Unlock()
+
+	for filename, info := range progress {
+		if info.Percentage >= 100 || info.Status == "failed" || info.Status == "aborted" {
+			delete(progress, filename)
+		}
+	}
+}
+
+func updateProgress(filename string, value float64, currentFile, status string) {
+	paused := false
+	if jobInfo, exists := getJob(filename); exists {
+		paused = jobInfo.IsPaused()
+	}
+
+	progressMutex.Lock()
+	defer progressMutex.Unlock()
+
+	if existingProgress, ok := progress[filename]; ok {
+		existingProgress.Percentage = value
+		existingProgress.CurrentFile = currentFile
+		existingProgress.Paused = paused
+		if status != "" {
+			existingProgress.Status = status
+		}
+	} else {
+		progress[filename] = &ProgressInfo{
+			Percentage:  value,
+			CurrentFile: currentFile,
+			Paused:      paused,
+			Status:      status,
+		}
+	}
+}
+
+func handleSetSpeedLimit(w http.ResponseWriter, r *http.Request) {
+	if !ensureMethod(w, r, http.MethodPost) || !ensureAuthorized(w, r) {
+		return
+	}
+
+	logger.LogInfo("Set Speed Limit", "Received request to set speed limit")
+
+	var requestData struct {
+		SpeedLimit string `json:"speedLimit"`
+	}
+
+	if err := json.NewDecoder(r.Body).Decode(&requestData); err != nil {
+		logger.LogError("Set Speed Limit", "Invalid request body")
+		http.Error(w, "Invalid request", http.StatusBadRequest)
+		return
+	}
+
+	requestData.SpeedLimit = strings.TrimSpace(requestData.SpeedLimit)
+	if requestData.SpeedLimit == "unlimited" {
+		setGlobalSpeedLimit("")
+	} else {
+		if !speedLimitRegex.MatchString(requestData.SpeedLimit) {
+			http.Error(w, "Invalid speed limit format", http.StatusBadRequest)
+			return
+		}
+		setGlobalSpeedLimit(requestData.SpeedLimit)
+	}
+
+	logger.LogInfo("Set Speed Limit", fmt.Sprintf("Global speed limit set to: %s", getGlobalSpeedLimit()))
+	w.WriteHeader(http.StatusOK)
+}
--- a/src/handlers_pages.go
+++ b/src/handlers_pages.go
@@ -0,0 +1,128 @@
+package main
+
+import (
+	"encoding/json"
+	"fmt"
+	"net/http"
+	"net/url"
+	"os"
+	"strings"
+)
+
+func handleRoot(w http.ResponseWriter, r *http.Request) {
+	if !ensureMethod(w, r, http.MethodGet) || !ensureAuthorized(w, r) {
+		return
+	}
+
+	err := templates.ExecuteTemplate(w, "index", struct {
+		Jobs             map[string]ProgressInfo
+		GlobalSpeedLimit string
+		AuthToken        string
+		Nonce            string
+	}{
+		Jobs:             snapshotProgress(),
+		GlobalSpeedLimit: getGlobalSpeedLimit(),
+		AuthToken:        url.QueryEscape(config.Security.AuthToken),
+		Nonce:            cspNonce(r),
+	})
+	if err != nil {
+		logger.LogError("Handle Root", fmt.Sprintf("Error executing template: %v", err))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func handleSelect(w http.ResponseWriter, r *http.Request) {
+	if !ensureMethod(w, r, http.MethodGet) || !ensureAuthorized(w, r) {
+		return
+	}
+
+	filesParam := r.URL.Query().Get("files")
+	filenames := strings.Split(filesParam, ",")
+
+	allItems := make(map[string]map[string][]Item)
+
+	for _, filename := range filenames {
+		if filename == "" {
+			continue
+		}
+
+		fullPath, pathErr := safeUploadPath(filename)
+		if pathErr != nil {
+			logger.LogError("Handle Select", fmt.Sprintf("Invalid filename %s: %v", filename, pathErr))
+			continue
+		}
+
+		if _, err := os.Stat(fullPath); os.IsNotExist(err) {
+			logger.LogError("Handle Select", fmt.Sprintf("File does not exist: %s", fullPath))
+			continue
+		}
+
+		items, err := parseInputFile(fullPath)
+		if err != nil {
+			logger.LogError("Handle Select", fmt.Sprintf("Error parsing input file: %v", err))
+			continue
+		}
+
+		sortItems(items)
+
+		groupedItems := groupItemsBySeason(items)
+		allItems[filename] = groupedItems
+	}
+
+	if len(allItems) == 0 {
+		logger.LogError("Handle Select", "No valid files were processed")
+		http.Error(w, "No valid files were processed", http.StatusBadRequest)
+		return
+	}
+
+	err := templates.ExecuteTemplate(w, "select", struct {
+		Filenames string
+		AllItems  map[string]map[string][]Item
+		AuthToken string
+		Nonce     string
+	}{
+		Filenames: filesParam,
+		AllItems:  allItems,
+		AuthToken: url.QueryEscape(config.Security.AuthToken),
+		Nonce:     cspNonce(r),
+	})
+	if err != nil {
+		logger.LogError("Handle Select", fmt.Sprintf("Error executing template: %v", err))
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
+
+func handleProgress(w http.ResponseWriter, r *http.Request) {
+	if !ensureMethod(w, r, http.MethodGet) || !ensureAuthorized(w, r) {
+		return
+	}
+
+	filename := r.URL.Query().Get("filename")
+
+	if r.Header.Get("Accept") == "application/json" {
+		progressInfo := getProgress(filename)
+
+		if progressInfo == nil {
+			w.WriteHeader(http.StatusNotFound)
+			_ = json.NewEncoder(w).Encode(map[string]string{"error": "No progress information found"})
+			return
+		}
+
+		w.Header().Set("Content-Type", "application/json")
+		err := json.NewEncoder(w).Encode(progressInfo)
+		if err != nil {
+			http.Error(w, "Internal Server Error", http.StatusInternalServerError)
+			return
+		}
+		return
+	}
+
+	err := templates.ExecuteTemplate(w, "progress", struct {
+		Filename  string
+		AuthToken string
+		Nonce     string
+	}{Filename: filename, AuthToken: url.QueryEscape(config.Security.AuthToken), Nonce: cspNonce(r)})
+	if err != nil {
+		http.Error(w, err.Error(), http.StatusInternalServerError)
+	}
+}
--- a/src/handlers_upload_process.go
+++ b/src/handlers_upload_process.go
@@ -0,0 +1,158 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"net/http"
+	"net/url"
+	"os"
+	"path/filepath"
+	"strings"
+)
+
+func handleUpload(w http.ResponseWriter, r *http.Request) {
+	if !ensureMethod(w, r, http.MethodPost) || !ensureAuthorized(w, r) {
+		return
+	}
+
+	logger.LogInfo("Handle Upload", "Starting file upload")
+	r.Body = http.MaxBytesReader(w, r.Body, maxUploadBytes())
+	const multipartMemory = 4 << 20
+	err := r.ParseMultipartForm(multipartMemory)
+	if err != nil {
+		logger.LogError("Handle Upload", fmt.Sprintf("Error parsing multipart form: %v", err))
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	files := r.MultipartForm.File["files"]
+	if len(files) == 0 {
+		logger.LogError("Handle Upload", "No files uploaded")
+		http.Error(w, "No files uploaded", http.StatusBadRequest)
+		return
+	}
+
+	uploadedFiles := []string{}
+
+	for _, fileHeader := range files {
+		if strings.ToLower(filepath.Ext(fileHeader.Filename)) != ".drmd" {
+			http.Error(w, "Only .drmd files are allowed", http.StatusBadRequest)
+			return
+		}
+
+		file, err := fileHeader.Open()
+		if err != nil {
+			logger.LogError("Handle Upload", fmt.Sprintf("Error opening file: %v", err))
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		pattern := sanitizeFilename(fileHeader.Filename) + "_*.drmd"
+		tempFile, err := os.CreateTemp(uploadDir, pattern)
+		if err != nil {
+			_ = file.Close()
+			logger.LogError("Handle Upload", fmt.Sprintf("Error creating temporary file: %v", err))
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		_, err = io.Copy(tempFile, file)
+		_ = file.Close()
+		if err != nil {
+			_ = tempFile.Close()
+			_ = os.Remove(tempFile.Name())
+			logger.LogError("Handle Upload", fmt.Sprintf("Error copying file: %v", err))
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		if err := tempFile.Close(); err != nil {
+			_ = os.Remove(tempFile.Name())
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		uploadedFiles = append(uploadedFiles, filepath.Base(tempFile.Name()))
+
+		_, err = parseInputFile(tempFile.Name())
+		if err != nil {
+			_ = os.Remove(tempFile.Name())
+			logger.LogError("Handle Upload", fmt.Sprintf("Error parsing input file: %v", err))
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+	}
+
+	validFiles := []string{}
+	for _, file := range uploadedFiles {
+		if file != "" {
+			validFiles = append(validFiles, file)
+		}
+	}
+
+	if len(validFiles) == 0 {
+		logger.LogError("Handle Upload", "No valid files were uploaded")
+		http.Error(w, "No valid files were uploaded", http.StatusBadRequest)
+		return
+	}
+
+	logger.LogInfo("Handle Upload", fmt.Sprintf("Redirecting to select with files: %v", validFiles))
+	http.Redirect(w, r, withToken("/select?files="+url.QueryEscape(strings.Join(validFiles, ","))), http.StatusSeeOther)
+}
+
+func handleProcess(w http.ResponseWriter, r *http.Request) {
+	if !ensureMethod(w, r, http.MethodPost) || !ensureAuthorized(w, r) {
+		return
+	}
+
+	logger.LogInfo("Handle Process", "Starting process")
+	if err := r.ParseForm(); err != nil {
+		logger.LogError("Handle Process", fmt.Sprintf("Error parsing form: %v", err))
+		http.Error(w, err.Error(), http.StatusBadRequest)
+		return
+	}
+
+	selectedItems := r.Form["items"]
+	if len(selectedItems) == 0 {
+		logger.LogError("Handle Process", "No items selected")
+		http.Error(w, "No items selected", http.StatusBadRequest)
+		return
+	}
+
+	itemsByFile := make(map[string][]string)
+	for _, item := range selectedItems {
+		parts := strings.SplitN(item, ":", 2)
+		if len(parts) != 2 {
+			logger.LogError("Handle Process", "Invalid item format")
+			continue
+		}
+		filename, itemName := parts[0], parts[1]
+		itemsByFile[filename] = append(itemsByFile[filename], itemName)
+	}
+
+	for filename, items := range itemsByFile {
+		logger.LogInfo("Handle Process", fmt.Sprintf("Processing file: %s", filename))
+		fullPath, pathErr := safeUploadPath(filename)
+		if pathErr != nil {
+			http.Error(w, pathErr.Error(), http.StatusBadRequest)
+			return
+		}
+
+		allItems, err := parseInputFile(fullPath)
+		if err != nil {
+			logger.LogError("Handle Process", fmt.Sprintf("Error parsing input file: %v", err))
+			http.Error(w, err.Error(), http.StatusInternalServerError)
+			return
+		}
+
+		selectedItems := filterSelectedItems(allItems, items)
+		sortItems(selectedItems)
+		go func(targetFilename string, targetItems []Item) {
+			if err := processItems(targetFilename, targetItems); err != nil {
+				logger.LogError("Handle Process", fmt.Sprintf("Error processing %s: %v", targetFilename, err))
+			}
+		}(filename, selectedItems)
+	}
+
+	http.Redirect(w, r, withToken("/"), http.StatusSeeOther)
+}
--- a/src/handlers_ws.go
+++ b/src/handlers_ws.go
@@ -0,0 +1,148 @@
+package main
+
+import (
+	"fmt"
+	"net/http"
+	"net/url"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/gorilla/websocket"
+)
+
+const (
+	wsSendBuffer  = 64
+	wsWriteWait   = 10 * time.Second
+)
+
+var upgrader = websocket.Upgrader{
+	CheckOrigin: func(r *http.Request) bool {
+		origin := strings.TrimSpace(r.Header.Get("Origin"))
+		if origin == "" {
+			return strings.TrimSpace(config.Security.AuthToken) == ""
+		}
+		parsedOrigin, err := url.Parse(origin)
+		if err != nil {
+			return false
+		}
+		return strings.EqualFold(parsedOrigin.Host, r.Host)
+	},
+}
+
+type wsClient struct {
+	conn *websocket.Conn
+	send chan []byte
+	once sync.Once
+}
+
+func (c *wsClient) close() {
+	c.once.Do(func() {
+		close(c.send)
+	})
+}
+
+var clients = make(map[string]map[*wsClient]struct{})
+var mu sync.Mutex
+
+func handleWebSocket(w http.ResponseWriter, r *http.Request) {
+	if !ensureMethod(w, r, http.MethodGet) || !ensureAuthorized(w, r) {
+		return
+	}
+
+	if !config.General.EnableConsole {
+		http.Error(w, "Console output is disabled", http.StatusForbidden)
+		return
+	}
+
+	filename := r.URL.Query().Get("filename")
+	if filename == "" {
+		http.Error(w, "Filename is required", http.StatusBadRequest)
+		return
+	}
+
+	conn, err := upgrader.Upgrade(w, r, nil)
+	if err != nil {
+		logger.LogError("WebSocket", fmt.Sprintf("Error while upgrading connection: %v", err))
+		return
+	}
+
+	logger.LogInfo("WebSocket", fmt.Sprintf("WebSocket connection established for filename: %s", filename))
+
+	client := &wsClient{conn: conn, send: make(chan []byte, wsSendBuffer)}
+
+	mu.Lock()
+	if clients[filename] == nil {
+		clients[filename] = make(map[*wsClient]struct{})
+	}
+	clients[filename][client] = struct{}{}
+	mu.Unlock()
+
+	go writePump(filename, client)
+
+	for {
+		if _, _, err := conn.NextReader(); err != nil {
+			break
+		}
+	}
+
+	mu.Lock()
+	if set, ok := clients[filename]; ok {
+		if _, exists := set[client]; exists {
+			delete(set, client)
+			client.close()
+		}
+		if len(set) == 0 {
+			delete(clients, filename)
+		}
+	}
+	mu.Unlock()
+	_ = conn.Close()
+
+	logger.LogInfo("WebSocket", fmt.Sprintf("WebSocket connection closed for filename: %s", filename))
+}
+
+func writePump(filename string, client *wsClient) {
+	defer client.conn.Close()
+
+	for message := range client.send {
+		if err := client.conn.SetWriteDeadline(time.Now().Add(wsWriteWait)); err != nil {
+			logger.LogError("WebSocket", fmt.Sprintf("SetWriteDeadline error: %v", err))
+			return
+		}
+		if err := client.conn.WriteMessage(websocket.TextMessage, message); err != nil {
+			logger.LogError("Broadcast", fmt.Sprintf("Error writing to client for %s: %v", filename, err))
+			return
+		}
+	}
+}
+
+func broadcast(filename string, message []byte) {
+	if !config.General.EnableConsole {
+		return
+	}
+
+	mu.Lock()
+	set := clients[filename]
+	targets := make([]*wsClient, 0, len(set))
+	for c := range set {
+		targets = append(targets, c)
+	}
+	mu.Unlock()
+
+	for _, client := range targets {
+		select {
+		case client.send <- message:
+		default:
+			mu.Lock()
+			if set, ok := clients[filename]; ok {
+				if _, exists := set[client]; exists {
+					delete(set, client)
+					client.close()
+				}
+			}
+			mu.Unlock()
+			logger.LogError("Broadcast", fmt.Sprintf("Dropping slow client for %s", filename))
+		}
+	}
+}
--- a/src/integration_test.go
+++ b/src/integration_test.go
@@ -0,0 +1,109 @@
+package main
+
+import (
+	"net/http"
+	"net/http/httptest"
+	"testing"
+)
+
+func resetStateForTest() {
+	jobsMutex.Lock()
+	jobs = make(map[string]*JobInfo)
+	jobsMutex.Unlock()
+
+	progressMutex.Lock()
+	progress = make(map[string]*ProgressInfo)
+	progressMutex.Unlock()
+
+	setGlobalSpeedLimit("")
+	config = Config{}
+	setDefaultConfigValues()
+}
+
+func TestAuthTokenProtection(t *testing.T) {
+	resetStateForTest()
+	config.Security.AuthToken = "secret"
+
+	handler := newRouter()
+
+	req := httptest.NewRequest(http.MethodPost, "/clear-completed", nil)
+	rr := httptest.NewRecorder()
+	handler.ServeHTTP(rr, req)
+
+	if rr.Code != http.StatusUnauthorized {
+		t.Fatalf("expected status %d, got %d", http.StatusUnauthorized, rr.Code)
+	}
+
+	req = httptest.NewRequest(http.MethodPost, "/clear-completed?token=secret", nil)
+	rr = httptest.NewRecorder()
+	handler.ServeHTTP(rr, req)
+
+	if rr.Code != http.StatusOK {
+		t.Fatalf("expected status %d, got %d", http.StatusOK, rr.Code)
+	}
+}
+
+func TestPauseResumeAbortFlow(t *testing.T) {
+	resetStateForTest()
+	handler := newRouter()
+
+	filename := "job.drmd"
+	setJob(filename, NewJobInfo())
+	updateProgress(filename, 10, "episode1", "running")
+
+	req := httptest.NewRequest(http.MethodPost, "/pause?filename="+filename, nil)
+	rr := httptest.NewRecorder()
+	handler.ServeHTTP(rr, req)
+	if rr.Code != http.StatusOK {
+		t.Fatalf("pause expected %d got %d", http.StatusOK, rr.Code)
+	}
+
+	job, ok := getJob(filename)
+	if !ok || !job.IsPaused() {
+		t.Fatalf("expected paused job state")
+	}
+
+	progressInfo := getProgress(filename)
+	if progressInfo == nil || progressInfo.Status != "paused" {
+		t.Fatalf("expected paused progress state")
+	}
+
+	req = httptest.NewRequest(http.MethodPost, "/resume?filename="+filename, nil)
+	rr = httptest.NewRecorder()
+	handler.ServeHTTP(rr, req)
+	if rr.Code != http.StatusOK {
+		t.Fatalf("resume expected %d got %d", http.StatusOK, rr.Code)
+	}
+
+	if job.IsPaused() {
+		t.Fatalf("expected resumed job state")
+	}
+
+	progressInfo = getProgress(filename)
+	if progressInfo == nil || progressInfo.Status != "running" {
+		t.Fatalf("expected running progress state")
+	}
+
+	req = httptest.NewRequest(http.MethodPost, "/abort?filename="+filename, nil)
+	rr = httptest.NewRecorder()
+	handler.ServeHTTP(rr, req)
+	if rr.Code != http.StatusOK {
+		t.Fatalf("abort expected %d got %d", http.StatusOK, rr.Code)
+	}
+
+	if !job.IsAborted() {
+		t.Fatalf("expected aborted job state")
+	}
+
+	progressInfo = getProgress(filename)
+	if progressInfo == nil || progressInfo.Status != "aborted" {
+		t.Fatalf("expected aborted progress state")
+	}
+
+	req = httptest.NewRequest(http.MethodPost, "/abort?filename="+filename, nil)
+	rr = httptest.NewRecorder()
+	handler.ServeHTTP(rr, req)
+	if rr.Code != http.StatusOK {
+		t.Fatalf("second abort expected %d got %d", http.StatusOK, rr.Code)
+	}
+}
--- a/src/logger.go
+++ b/src/logger.go
@@ -0,0 +1,36 @@
+package main
+
+import (
+	"log"
+	"os"
+)
+
+type Logger struct {
+	*log.Logger
+}
+
+const (
+	Reset  = "\033[0m"
+	Red    = "\033[31m"
+	Green  = "\033[32m"
+	Yellow = "\033[33m"
+	Blue   = "\033[34m"
+)
+
+func NewLogger(prefix string) *Logger {
+	return &Logger{
+		Logger: log.New(os.Stdout, prefix, log.Ldate|log.Ltime),
+	}
+}
+
+func (l *Logger) LogInfo(jobName, message string) {
+	l.Printf("%s[INFO] [%s] %s%s", Green, jobName, message, Reset)
+}
+
+func (l *Logger) LogError(jobName, message string) {
+	l.Printf("%s[ERROR] [%s] %s%s", Red, jobName, message, Reset)
+}
+
+func (l *Logger) LogJobState(jobName, state string) {
+	l.Printf("%s[JOB STATE] [%s] %s%s", Yellow, jobName, state, Reset)
+}
--- a/src/main.go
+++ b/src/main.go
@@ -0,0 +1,162 @@
+package main
+
+import (
+	"context"
+	"flag"
+	"fmt"
+	"html/template"
+	"net/http"
+	"os"
+	"os/signal"
+	"strings"
+	"sync"
+	"syscall"
+	"time"
+
+	"embed"
+)
+
+var logger *Logger
+
+type Item struct {
+	MPD         string
+	Keys        string
+	Filename    string
+	Description string
+	Subtitles   string
+	Poster      string
+	Metadata    string
+}
+
+type Items struct {
+	Items []Item
+}
+
+type Metadata struct {
+	Title  string
+	Type   string
+	Season string
+}
+
+const uploadDir = "uploads"
+
+var templates *template.Template
+
+//go:embed templates
+var templateFS embed.FS
+
+var globalSpeedLimit string
+var globalSpeedLimitMutex sync.RWMutex
+
+func getGlobalSpeedLimit() string {
+	globalSpeedLimitMutex.RLock()
+	defer globalSpeedLimitMutex.RUnlock()
+	return globalSpeedLimit
+}
+
+func setGlobalSpeedLimit(value string) {
+	globalSpeedLimitMutex.Lock()
+	defer globalSpeedLimitMutex.Unlock()
+	globalSpeedLimit = value
+}
+
+func init() {
+	if err := os.MkdirAll(uploadDir, 0755); err != nil {
+		fmt.Printf("Error creating upload directory: %v\n", err)
+	}
+
+	templates = template.Must(template.ParseFS(templateFS, "templates/*"))
+
+	logger = NewLogger("")
+}
+
+func main() {
+	configPath := flag.String("config", "config.toml", "Path to config file")
+	inputFile := flag.String("f", "", "Path to the input JSON file")
+	flag.Parse()
+
+	loadConfig(*configPath)
+
+	if *inputFile == "" {
+		go watchFolder()
+		startWebServer()
+	} else {
+		items, err := parseInputFile(*inputFile)
+		if err != nil {
+			logger.LogError("Main", fmt.Sprintf("Error parsing input file: %v", err))
+			return
+		}
+		if err := processItems(*inputFile, items); err != nil {
+			logger.LogError("Main", fmt.Sprintf("Error processing items: %v", err))
+		}
+	}
+}
+
+func startWebServer() {
+	server := &http.Server{
+		Addr:              serverAddr(),
+		Handler:           newRouter(),
+		ReadTimeout:       time.Duration(config.Server.ReadTimeoutSec) * time.Second,
+		ReadHeaderTimeout: time.Duration(config.Server.ReadHeaderTimeoutS) * time.Second,
+		WriteTimeout:      time.Duration(config.Server.WriteTimeoutSec) * time.Second,
+		IdleTimeout:       time.Duration(config.Server.IdleTimeoutSec) * time.Second,
+	}
+
+	ctx, stop := signal.NotifyContext(context.Background(), os.Interrupt, syscall.SIGTERM)
+	defer stop()
+
+	go func() {
+		<-ctx.Done()
+		logger.LogInfo("Main", "Shutdown signal received, aborting jobs")
+		abortAllJobs()
+
+		shutdownCtx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
+		defer cancel()
+		if err := server.Shutdown(shutdownCtx); err != nil {
+			logger.LogError("Main", fmt.Sprintf("Server shutdown error: %v", err))
+		}
+	}()
+
+	logger.LogInfo("Main", fmt.Sprintf("Starting web server on http://%s", server.Addr))
+	if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
+		logger.LogError("Main", fmt.Sprintf("Web server error: %v", err))
+	}
+}
+
+func abortAllJobs() {
+	jobsMutex.RLock()
+	jobList := make([]*JobInfo, 0, len(jobs))
+	for _, j := range jobs {
+		jobList = append(jobList, j)
+	}
+	jobsMutex.RUnlock()
+
+	for _, j := range jobList {
+		j.Abort()
+		j.KillProcess()
+	}
+}
+
+func getKeys(keys string) []string {
+	parts := strings.Split(keys, ",")
+	out := parts[:0]
+	for _, p := range parts {
+		p = strings.TrimSpace(p)
+		if p != "" {
+			out = append(out, p)
+		}
+	}
+	return out
+}
+
+func parseMetadata(metadata string) Metadata {
+	parts := strings.Split(metadata, ";")
+	if len(parts) != 3 {
+		return Metadata{}
+	}
+	return Metadata{
+		Title:  strings.TrimSpace(parts[0]),
+		Type:   strings.TrimSpace(parts[1]),
+		Season: "S" + strings.TrimSpace(parts[2]),
+	}
+}
--- a/src/main_test.go
+++ b/src/main_test.go
@@ -0,0 +1,176 @@
+package main
+
+import (
+	"encoding/json"
+	"os"
+	"path/filepath"
+	"reflect"
+	"testing"
+)
+
+func TestSanitizeFilename(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected string
+	}{
+		{"file:name.mp4", "file_name.mp4"},
+		{"file/name.mp4", "file_name.mp4"},
+		{"file\\name.mp4", "file_name.mp4"},
+		{"file?name.mp4", "file_name.mp4"},
+		{"file*name.mp4", "file_name.mp4"},
+		{"file<name>.mp4", "file_name_.mp4"},
+		{".hidden", "hidden"},
+	}
+
+	for _, test := range tests {
+		result := sanitizeFilename(test.input)
+		if result != test.expected {
+			t.Errorf("sanitizeFilename(%q) = %q, want %q", test.input, result, test.expected)
+		}
+	}
+}
+
+func TestIsValidURL(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected bool
+	}{
+		{"https://example.com", true},
+		{"http://example.com", true},
+		{"ftp://example.com", true},
+		{"not a url", false},
+	}
+
+	for _, test := range tests {
+		result := isValidURL(test.input)
+		if result != test.expected {
+			t.Errorf("isValidURL(%q) = %v, want %v", test.input, result, test.expected)
+		}
+	}
+}
+
+func TestParseMetadata(t *testing.T) {
+	tests := []struct {
+		input    string
+		expected Metadata
+	}{
+		{"Show Title; serie; 01", Metadata{Title: "Show Title", Type: "serie", Season: "S01"}},
+		{"Movie Title; movie; ", Metadata{Title: "Movie Title", Type: "movie", Season: "S"}},
+		{"Invalid Metadata", Metadata{}},
+	}
+
+	for _, test := range tests {
+		result := parseMetadata(test.input)
+		if !reflect.DeepEqual(result, test.expected) {
+			t.Errorf("parseMetadata(%q) = %v, want %v", test.input, result, test.expected)
+		}
+	}
+}
+
+func TestParseInputFile(t *testing.T) {
+	tempFile, err := os.CreateTemp("", "test_input_*.json")
+	if err != nil {
+		t.Fatalf("Failed to create temp file: %v", err)
+	}
+	defer os.Remove(tempFile.Name())
+
+	testData := Items{
+		Items: []Item{
+			{MPD: "http://example.com/video1.mpd", Filename: "video1.mp4"},
+			{MPD: "http://example.com/video2.mpd", Filename: "video2.mp4"},
+		},
+	}
+	jsonData, _ := json.Marshal(testData)
+	if _, err := tempFile.Write(jsonData); err != nil {
+		t.Fatalf("Failed to write to temp file: %v", err)
+	}
+	tempFile.Close()
+
+	items, err := parseInputFile(tempFile.Name())
+	if err != nil {
+		t.Fatalf("parseInputFile() returned an error: %v", err)
+	}
+
+	if len(items) != len(testData.Items) {
+		t.Errorf("parseInputFile() returned %d items, want %d", len(items), len(testData.Items))
+	}
+
+	for i, item := range items {
+		if !reflect.DeepEqual(item, testData.Items[i]) {
+			t.Errorf("parseInputFile() item %d = %v, want %v", i, item, testData.Items[i])
+		}
+	}
+}
+
+func TestGroupItemsBySeason(t *testing.T) {
+	items := []Item{
+		{Filename: "show1_s01e01.mp4", Metadata: "Show 1; serie; 01"},
+		{Filename: "show1_s01e02.mp4", Metadata: "Show 1; serie; 01"},
+		{Filename: "show2_s01e01.mp4", Metadata: "Show 2; serie; 01"},
+		{Filename: "movie1.mp4", Metadata: "Movie 1; movie; "},
+	}
+
+	grouped := groupItemsBySeason(items)
+
+	expectedGroups := map[string]int{
+		"Show 1 - S01": 2,
+		"Show 2 - S01": 1,
+		"Movies":       1,
+	}
+
+	for group, count := range expectedGroups {
+		if len(grouped[group]) != count {
+			t.Errorf("groupItemsBySeason() group %q has %d items, want %d", group, len(grouped[group]), count)
+		}
+	}
+}
+
+func TestSafeUploadPath(t *testing.T) {
+	tests := []struct {
+		name      string
+		input     string
+		wantError bool
+	}{
+		{name: "valid filename", input: "file.drmd", wantError: false},
+		{name: "directory traversal", input: "../file.drmd", wantError: true},
+		{name: "empty", input: "", wantError: true},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			path, err := safeUploadPath(tc.input)
+			if tc.wantError && err == nil {
+				t.Fatalf("expected error for input %q", tc.input)
+			}
+			if !tc.wantError {
+				if err != nil {
+					t.Fatalf("unexpected error: %v", err)
+				}
+				if filepath.Base(path) != tc.input {
+					t.Fatalf("expected basename %q, got %q", tc.input, filepath.Base(path))
+				}
+			}
+		})
+	}
+}
+
+func TestValidateRemoteURL(t *testing.T) {
+	tests := []struct {
+		name      string
+		input     string
+		wantError bool
+	}{
+		{name: "reject localhost", input: "http://localhost/test.vtt", wantError: true},
+		{name: "reject invalid scheme", input: "file:///tmp/test", wantError: true},
+		{name: "reject malformed", input: "::://", wantError: true},
+	}
+
+	for _, tc := range tests {
+		t.Run(tc.name, func(t *testing.T) {
+			_, err := validateRemoteURL(tc.input)
+			if tc.wantError && err == nil {
+				t.Fatalf("expected error for %q", tc.input)
+			}
+		})
+	}
+}
--- a/src/router.go
+++ b/src/router.go
@@ -0,0 +1,19 @@
+package main
+
+import "net/http"
+
+func newRouter() http.Handler {
+	mux := http.NewServeMux()
+	mux.HandleFunc("/", handleRoot)
+	mux.HandleFunc("/upload", handleUpload)
+	mux.HandleFunc("/select", handleSelect)
+	mux.HandleFunc("/process", handleProcess)
+	mux.HandleFunc("/progress", handleProgress)
+	mux.HandleFunc("/abort", handleAbort)
+	mux.HandleFunc("/pause", handlePause)
+	mux.HandleFunc("/resume", handleResume)
+	mux.HandleFunc("/clear-completed", handleClearCompleted)
+	mux.HandleFunc("/ws", handleWebSocket)
+	mux.HandleFunc("/set-speed-limit", handleSetSpeedLimit)
+	return withSecurityHeaders(mux)
+}
--- a/src/security.go
+++ b/src/security.go
@@ -0,0 +1,237 @@
+package main
+
+import (
+	"context"
+	"crypto/rand"
+	"crypto/subtle"
+	"encoding/base64"
+	"errors"
+	"fmt"
+	"io"
+	"net"
+	"net/http"
+	"net/url"
+	"strings"
+	"time"
+)
+
+var blockedCIDRs = mustParseCIDRs([]string{
+	"127.0.0.0/8",
+	"10.0.0.0/8",
+	"172.16.0.0/12",
+	"192.168.0.0/16",
+	"169.254.0.0/16",
+	"100.64.0.0/10",
+	"0.0.0.0/8",
+	"::1/128",
+	"fc00::/7",
+	"fe80::/10",
+})
+
+var secureDialer = &net.Dialer{
+	Timeout:   10 * time.Second,
+	KeepAlive: 30 * time.Second,
+}
+
+var secureTransport = &http.Transport{
+	DialContext: func(ctx context.Context, network, addr string) (net.Conn, error) {
+		host, port, err := net.SplitHostPort(addr)
+		if err != nil {
+			return nil, err
+		}
+		ips, err := net.DefaultResolver.LookupIPAddr(ctx, host)
+		if err != nil {
+			return nil, err
+		}
+		for _, ip := range ips {
+			if isBlockedIP(ip.IP) {
+				return nil, fmt.Errorf("dial blocked: %s resolves to %s", host, ip.IP)
+			}
+		}
+		if len(ips) == 0 {
+			return nil, fmt.Errorf("no IPs for %s", host)
+		}
+		return secureDialer.DialContext(ctx, network, net.JoinHostPort(ips[0].IP.String(), port))
+	},
+	TLSHandshakeTimeout:   10 * time.Second,
+	ResponseHeaderTimeout: 30 * time.Second,
+}
+
+var secureHTTPClient = &http.Client{
+	Timeout:   30 * time.Second,
+	Transport: secureTransport,
+	CheckRedirect: func(req *http.Request, _ []*http.Request) error {
+		_, err := validateRemoteURL(req.URL.String())
+		return err
+	},
+}
+
+const maxRemoteFetchBytes int64 = 20 << 20
+
+func mustParseCIDRs(cidrs []string) []*net.IPNet {
+	networks := make([]*net.IPNet, 0, len(cidrs))
+	for _, cidr := range cidrs {
+		_, network, err := net.ParseCIDR(cidr)
+		if err != nil {
+			panic(err)
+		}
+		networks = append(networks, network)
+	}
+	return networks
+}
+
+func maxUploadBytes() int64 {
+	return int64(config.General.MaxUploadMB) << 20
+}
+
+func serverAddr() string {
+	return fmt.Sprintf("%s:%d", config.Server.Host, config.Server.Port)
+}
+
+func ensureMethod(w http.ResponseWriter, r *http.Request, method string) bool {
+	if r.Method != method {
+		http.Error(w, "Method not allowed", http.StatusMethodNotAllowed)
+		return false
+	}
+	return true
+}
+
+func ensureAuthorized(w http.ResponseWriter, r *http.Request) bool {
+	token := strings.TrimSpace(config.Security.AuthToken)
+	if token == "" {
+		return true
+	}
+
+	providedToken := strings.TrimSpace(r.Header.Get("X-DRMD-Token"))
+	if providedToken == "" {
+		providedToken = strings.TrimSpace(r.URL.Query().Get("token"))
+	}
+
+	if subtle.ConstantTimeCompare([]byte(providedToken), []byte(token)) != 1 {
+		http.Error(w, "Unauthorized", http.StatusUnauthorized)
+		return false
+	}
+
+	return true
+}
+
+func validateRemoteURL(rawURL string) (*url.URL, error) {
+	parsedURL, err := url.Parse(strings.TrimSpace(rawURL))
+	if err != nil {
+		return nil, fmt.Errorf("invalid URL: %w", err)
+	}
+
+	if parsedURL.Scheme != "http" && parsedURL.Scheme != "https" {
+		return nil, errors.New("only http(s) URLs are allowed")
+	}
+
+	host := parsedURL.Hostname()
+	if host == "" {
+		return nil, errors.New("URL host is required")
+	}
+
+	if strings.EqualFold(host, "localhost") {
+		return nil, errors.New("localhost URLs are not allowed")
+	}
+
+	ips, err := net.LookupIP(host)
+	if err != nil {
+		return nil, fmt.Errorf("unable to resolve URL host: %w", err)
+	}
+
+	for _, ip := range ips {
+		if isBlockedIP(ip) {
+			return nil, fmt.Errorf("URL host resolves to blocked IP range: %s", ip.String())
+		}
+	}
+
+	return parsedURL, nil
+}
+
+func isBlockedIP(ip net.IP) bool {
+	if ip.IsLoopback() || ip.IsPrivate() || ip.IsUnspecified() || ip.IsLinkLocalMulticast() || ip.IsLinkLocalUnicast() || ip.IsMulticast() {
+		return true
+	}
+
+	for _, network := range blockedCIDRs {
+		if network.Contains(ip) {
+			return true
+		}
+	}
+
+	return false
+}
+
+func fetchRemoteContent(rawURL string) ([]byte, error) {
+	validatedURL, err := validateRemoteURL(rawURL)
+	if err != nil {
+		return nil, err
+	}
+
+	req, err := http.NewRequest(http.MethodGet, validatedURL.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+
+	resp, err := secureHTTPClient.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode < 200 || resp.StatusCode >= 300 {
+		return nil, fmt.Errorf("unexpected status code %d", resp.StatusCode)
+	}
+
+	if resp.ContentLength > maxRemoteFetchBytes {
+		return nil, fmt.Errorf("remote content too large: %d bytes", resp.ContentLength)
+	}
+
+	limited := io.LimitReader(resp.Body, maxRemoteFetchBytes+1)
+	body, err := io.ReadAll(limited)
+	if err != nil {
+		return nil, err
+	}
+
+	if int64(len(body)) > maxRemoteFetchBytes {
+		return nil, fmt.Errorf("remote content exceeded %d bytes", maxRemoteFetchBytes)
+	}
+
+	return body, nil
+}
+
+type ctxKey string
+
+const nonceCtxKey ctxKey = "csp-nonce"
+
+func generateNonce() string {
+	var b [16]byte
+	if _, err := rand.Read(b[:]); err != nil {
+		return ""
+	}
+	return base64.RawStdEncoding.EncodeToString(b[:])
+}
+
+func cspNonce(r *http.Request) string {
+	if v, ok := r.Context().Value(nonceCtxKey).(string); ok {
+		return v
+	}
+	return ""
+}
+
+func withSecurityHeaders(next http.Handler) http.Handler {
+	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
+		nonce := generateNonce()
+		w.Header().Set("X-Content-Type-Options", "nosniff")
+		w.Header().Set("X-Frame-Options", "DENY")
+		w.Header().Set("Referrer-Policy", "no-referrer")
+		csp := fmt.Sprintf(
+			"default-src 'self'; connect-src 'self'; img-src 'self' data:; style-src 'self' 'nonce-%s'; script-src 'self' 'nonce-%s'; base-uri 'self'; form-action 'self'; frame-ancestors 'none'",
+			nonce, nonce,
+		)
+		w.Header().Set("Content-Security-Policy", csp)
+
+		ctx := context.WithValue(r.Context(), nonceCtxKey, nonce)
+		next.ServeHTTP(w, r.WithContext(ctx))
+	})
+}
--- a/src/state.go
+++ b/src/state.go
@@ -0,0 +1,67 @@
+package main
+
+import "sync"
+
+var (
+	jobsMutex sync.RWMutex
+	jobs      = make(map[string]*JobInfo)
+
+	progressMutex sync.RWMutex
+	progress      = make(map[string]*ProgressInfo)
+)
+
+func setJob(filename string, jobInfo *JobInfo) {
+	jobsMutex.Lock()
+	defer jobsMutex.Unlock()
+	jobs[filename] = jobInfo
+}
+
+func getJob(filename string) (*JobInfo, bool) {
+	jobsMutex.RLock()
+	defer jobsMutex.RUnlock()
+	jobInfo, ok := jobs[filename]
+	return jobInfo, ok
+}
+
+func removeJob(filename string) {
+	jobsMutex.Lock()
+	defer jobsMutex.Unlock()
+	delete(jobs, filename)
+}
+
+func getProgress(filename string) *ProgressInfo {
+	progressMutex.RLock()
+	defer progressMutex.RUnlock()
+	if p, ok := progress[filename]; ok {
+		snapshot := *p
+		return &snapshot
+	}
+	return nil
+}
+
+func snapshotProgress() map[string]ProgressInfo {
+	progressMutex.RLock()
+	defer progressMutex.RUnlock()
+
+	result := make(map[string]ProgressInfo, len(progress))
+	for filename, info := range progress {
+		result[filename] = *info
+	}
+
+	return result
+}
+
+func setProgressStatus(filename string, paused *bool, status string) {
+	progressMutex.Lock()
+	defer progressMutex.Unlock()
+	info, ok := progress[filename]
+	if !ok {
+		return
+	}
+	if paused != nil {
+		info.Paused = *paused
+	}
+	if status != "" {
+		info.Status = status
+	}
+}
--- a/src/subtitles.go
+++ b/src/subtitles.go
@@ -0,0 +1,73 @@
+package main
+
+import (
+	"bytes"
+	"fmt"
+	"io"
+	"os"
+	"strings"
+
+	"github.com/asticode/go-astisub"
+)
+
+func downloadAndConvertSubtitles(subtitlesURLs string) ([]string, error) {
+	var subtitlePaths []string
+	urls := strings.Split(subtitlesURLs, ",")
+
+	for _, url := range urls {
+		logger.LogInfo("Subtitle Download", fmt.Sprintf("Downloading subtitle from %s", url))
+		vttPath, err := downloadSubtitle(url)
+		if err != nil {
+			logger.LogError("Subtitle Download", fmt.Sprintf("Error downloading subtitle: %v", err))
+			return nil, fmt.Errorf("error downloading subtitle: %v", err)
+		}
+
+		srtPath, err := convertVTTtoSRT(vttPath)
+		if err != nil {
+			logger.LogError("Subtitle Download", fmt.Sprintf("Error converting subtitle: %v", err))
+			return nil, fmt.Errorf("error converting subtitle: %v", err)
+		}
+
+		subtitlePaths = append(subtitlePaths, srtPath)
+	}
+
+	return subtitlePaths, nil
+}
+
+func downloadSubtitle(url string) (string, error) {
+	logger.LogInfo("Download Subtitle", fmt.Sprintf("Starting download from %s", url))
+	body, err := fetchRemoteContent(url)
+	if err != nil {
+		logger.LogError("Download Subtitle", fmt.Sprintf("Error getting subtitle URL: %v", err))
+		return "", err
+	}
+
+	tempFile, err := os.CreateTemp("", "subtitle_*.vtt")
+	if err != nil {
+		logger.LogError("Download Subtitle", fmt.Sprintf("Error creating temp file: %v", err))
+		return "", err
+	}
+	defer tempFile.Close()
+
+	_, err = io.Copy(tempFile, bytes.NewReader(body))
+	if err != nil {
+		logger.LogError("Download Subtitle", fmt.Sprintf("Error copying to temp file: %v", err))
+		return "", err
+	}
+
+	logger.LogInfo("Download Subtitle", "Subtitle downloaded successfully")
+	return tempFile.Name(), nil
+}
+
+func convertVTTtoSRT(vttPath string) (string, error) {
+	srtPath := strings.TrimSuffix(vttPath, ".vtt") + ".srt"
+	s1, err := astisub.OpenFile(vttPath)
+	if err != nil {
+		return "", err
+	}
+	if err := s1.Write(srtPath); err != nil {
+		return "", err
+	}
+	logger.LogInfo("Convert VTT to SRT", fmt.Sprintf("Converted %s to %s", vttPath, srtPath))
+	return srtPath, nil
+}
--- a/src/templates/index
+++ b/src/templates/index
@@ -0,0 +1,323 @@
+<!DOCTYPE html>
+<html lang="en">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Simple Downloader</title>
+    <style nonce="{{.Nonce}}">
+        body {
+            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
+            background-color: #1e1e1e;
+            color: #d4d4d4;
+            line-height: 1.6;
+            padding: 20px;
+            max-width: 900px;
+            margin: 0 auto;
+            box-sizing: border-box;
+        }
+        h1, h2 {
+            border-bottom: 1px solid #333;
+            padding-bottom: 10px;
+            word-wrap: break-word;
+        }
+        form {
+            margin-bottom: 20px;
+            display: flex;
+            flex-direction: column;
+        }
+        input[type="file"], input[type="submit"] {
+            background-color: #2d2d2d;
+            color: #d4d4d4;
+            padding: 8px 12px;
+            border-radius: 4px;
+            margin-bottom: 10px;
+            max-width: 100%;
+        }
+        input[type="submit"] {
+            cursor: pointer;
+            background-color: #4CAF50;
+            color: white;
+        }
+        input[type="submit"]:hover {
+            background-color: #45a049;
+        }
+        ul {
+            list-style-type: none;
+            padding: 0;
+            margin-bottom: 10px; 
+        }
+        li {
+            background-color: #2d2d2d;
+            margin-bottom: 10px;
+            padding: 10px;
+            border-radius: 4px;
+            word-wrap: break-word;
+        }
+        .job-title {
+            font-size: 1.1em;
+            font-weight: bold;
+            margin-bottom: 5px;
+        }
+        .job-title a {
+            color: #58a6ff;
+            text-decoration: none;
+        }
+        .job-title a:hover {
+            text-decoration: underline;
+        }
+        .job-info {
+            font-size: 0.9em;
+            color: #a0a0a0;
+        }
+        .progress-text {
+            display: inline-block;
+            width: 5em;
+        }
+        .paused {
+            color: #ffa500;
+        }
+        .speed-limit {
+            font-size: 1em;
+            color: #a0a0a0;
+            margin-top: 10px;
+        }
+        @media (max-width: 600px) {
+            body {
+                padding: 10px;
+            }
+            h1, h2 {
+                font-size: 1.5em;
+            }
+            input[type="file"], input[type="submit"] {
+                font-size: 16px;
+            }
+            input[type="submit"], #clear-completed {
+                font-size: 16px;
+            }
+        }
+        input[type="submit"], #clear-completed {
+            cursor: pointer;
+            color: white;
+            border: 1px solid #444;
+            padding: 8px 12px;
+            border-radius: 4px;
+            margin-bottom: 10px;
+            max-width: 100%;
+            width: 100%;
+        }
+        #clear-completed {
+            background-color: #f44336;
+        }
+        #clear-completed:hover {
+            background-color: #d32f2f;
+        }
+        /* New CSS for speed limit form */
+        .settings-section {
+            margin-top: 30px;
+        }
+        .speed-limit-form {
+            display: flex;
+            align-items: center;
+            justify-content: space-between;
+            gap: 10px;
+            margin-bottom: 20px;
+        }
+        .speed-limit-form .form-group {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+        }
+        .speed-limit-form input[type="number"],
+        .speed-limit-form select,
+        .speed-limit-form button {
+            background-color: #2d2d2d;
+            color: #d4d4d4;
+            border: 1px solid #444;
+            padding: 8px 12px;
+            border-radius: 4px;
+        }
+        .speed-limit-form button {
+            cursor: pointer;
+            background-color: #4CAF50;
+            color: white;
+        }
+        .speed-limit-form button:hover {
+            background-color: #45a049;
+        }
+        .speed-limit-container {
+            display: flex;
+            align-items: center;
+            margin-bottom: 20px;
+            background-color: #2d2d2d;
+            padding: 8px 12px;
+            border-radius: 4px;
+        }
+        .speed-limit-container .form-group {
+            display: flex;
+            align-items: center;
+            gap: 10px;
+            width: 100%;
+        }
+        .speed-limit-container input[type="number"] {
+            background-color: #2d2d2d;
+            color: #d4d4d4;
+            border: 1px solid #444;
+            padding: 8px 12px;
+            border-radius: 4px;
+            height: 40px;
+            box-sizing: border-box;
+            flex-grow: 1;
+        }
+        .speed-limit-container select,
+        .speed-limit-container button {
+            background-color: #2d2d2d;
+            color: #d4d4d4;
+            border: 1px solid #444;
+            padding: 8px 12px;
+            border-radius: 4px;
+            height: 40px;
+            box-sizing: border-box;
+        }
+        .speed-limit-container button {
+            cursor: pointer;
+            background-color: #4CAF50;
+            color: white;
+        }
+        .speed-limit-container button:hover {
+            background-color: #45a049;
+        }
+        .speed-limit-container .speed-limit {
+            color: #d4d4d4;
+            margin-left: auto;
+            display: flex;
+            align-items: center;
+        }
+        .speed-limit-container .speed-limit span {
+            margin-left: 5px;
+        }
+        .current-speed-limit {
+            color: #d4d4d4;
+            margin-top: 10px;
+        }
+    </style>
+</head>
+<body>
+    <h1>Simple Downloader</h1>
+    <form action="{{if .AuthToken}}/upload?token={{.AuthToken}}{{else}}/upload{{end}}" method="post" enctype="multipart/form-data">
+        <input type="file" name="files" accept=".drmd" multiple>
+        <input type="submit" value="Upload and Process">
+    </form>
+    <h2>Currently Running Jobs</h2>
+    <ul>
+        {{range $filename, $info := .Jobs}}
+            <li>
+                <div class="job-title">
+                    <a href="{{if $.AuthToken}}/progress?filename={{$filename}}&token={{$.AuthToken}}{{else}}/progress?filename={{$filename}}{{end}}">{{$filename}}</a>
+                </div>
+                <div class="job-info">
+                    Progress: <span class="progress-text">{{printf "%5.1f%%" $info.Percentage}}</span>
+                    Current file: {{$info.CurrentFile}}
+                    Status: {{$info.Status}}
+                    {{if $info.Paused}}
+                        <span class="paused">(Paused)</span>
+                    {{end}}
+                </div>
+            </li>
+        {{else}}
+            <li>No active jobs</li>
+        {{end}}
+    </ul>
+    <button id="clear-completed">Clear Completed Jobs</button>
+    
+    <div class="settings-section">
+        <h2>Settings</h2>
+        <div class="speed-limit-container">
+            <div class="form-group">
+                <label for="speedLimitValue">Speed Limit:</label>
+                <input type="number" id="speedLimitValue" name="speedLimitValue" min="0" step="0.01" required>
+                <select id="speedLimitUnit" name="speedLimitUnit">
+                    <option value="GBps">GBps</option>
+                    <option value="MBps" selected>MBps</option>
+                    <option value="KBps">KBps</option>
+                </select>
+                <button id="set-speed-limit" type="button">Set Limit</button>
+            </div>
+        </div>
+    </div>
+
+    <script nonce="{{.Nonce}}">
+        const authToken = "{{.AuthToken}}";
+        const currentSpeedLimitRaw = "{{if .GlobalSpeedLimit}}{{.GlobalSpeedLimit}}{{else}}0{{end}}";
+
+        function withToken(path) {
+            if (!authToken) {
+                return path;
+            }
+
+            const separator = path.includes('?') ? '&' : '?';
+            return `${path}${separator}token=${authToken}`;
+        }
+
+        function clearCompleted() {
+            fetch(withToken('/clear-completed'), { method: 'POST' })
+                .then(response => response.json())
+                .then(data => {
+                    if (data.success) {
+                        location.reload();
+                    } else {
+                        alert('Failed to clear completed jobs');
+                    }
+                });
+        }
+
+        function updateSpeedLimit(event) {
+            event.preventDefault();
+
+            const speedLimitValue = document.getElementById('speedLimitValue').value;
+            const speedLimitUnit = document.getElementById('speedLimitUnit').value;
+            const speedLimit = speedLimitValue === "0" ? "unlimited" : speedLimitValue + speedLimitUnit;
+
+            if (!validateSpeedLimit(speedLimitValue)) {
+                alert('Please enter a valid speed limit.');
+                return;
+            }
+
+            fetch(withToken('/set-speed-limit'), {
+                method: 'POST',
+                headers: {
+                    'Content-Type': 'application/json',
+                },
+                body: JSON.stringify({ speedLimit }),
+            }).then(response => {
+                if (response.ok) {
+                    alert('Speed limit updated successfully');
+                } else {
+                    alert('Failed to update speed limit');
+                }
+            });
+        }
+
+        function validateSpeedLimit(value) {
+            const number = parseFloat(value);
+            return !isNaN(number) && number >= 0;
+        }
+
+        document.addEventListener('DOMContentLoaded', function() {
+            const speedLimitValueInput = document.getElementById('speedLimitValue');
+            const speedLimitUnitSelect = document.getElementById('speedLimitUnit');
+
+            const match = currentSpeedLimitRaw.match(/(\d+(\.\d+)?)([A-Za-z]+)/);
+            if (match) {
+                speedLimitValueInput.value = match[1];
+                speedLimitUnitSelect.value = match[3];
+            } else {
+                speedLimitValueInput.value = "0";
+                speedLimitUnitSelect.value = "MBps";
+            }
+
+            document.getElementById('clear-completed').addEventListener('click', clearCompleted);
+            document.getElementById('set-speed-limit').addEventListener('click', updateSpeedLimit);
+        });
+    </script>
+</body>
+</html>
--- a/src/templates/progress
+++ b/src/templates/progress
@@ -4,14 +4,14 @@
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Processing {{.Filename}}</title>
-    <style>
+    <style nonce="{{.Nonce}}">
        body {
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
            background-color: #1e1e1e;
            color: #d4d4d4;
            line-height: 1.6;
            padding: 20px;
-            max-width: 800px;
+            max-width: 900px;
            margin: 0 auto;
            box-sizing: border-box;
        }
@@ -68,7 +68,7 @@
        #abort-button:hover {
            background-color: #d32f2f;
        }
-        #pause-button, #resume-button {
+        #pause-button, #resume-button, #toggle-console {
            background-color: #4CAF50;
            color: white;
            border: none;
@@ -77,7 +77,7 @@
            border-radius: 4px;
            cursor: pointer;
        }
-        #pause-button:hover, #resume-button:hover {
+        #pause-button:hover, #resume-button:hover, #toggle-console:hover {
            background-color: #45a049;
        }
        #resume-button {
@@ -96,6 +96,17 @@
        #back-button:hover {
            background-color: #1976D2;
        }
+        #console {
+            display: none; /* Initially hidden */
+            background-color: black;
+            color: white;
+            height: 300px; /* Adjust height as needed */
+            overflow-y: scroll;
+            white-space: pre; /* Preserve whitespace */
+            font-family: monospace; /* Use monospace font */
+            margin-top: 10px;
+            border: 1px solid #ccc;
+        }
        @media (max-width: 600px) {
            body {
                padding: 10px;
@@ -125,16 +136,29 @@
        <div id="currentFile"></div>
    </div>
    <div>
-        <button id="abort-button" onclick="abortDownload()">Abort Download</button>
-        <button id="pause-button" onclick="pauseDownload()">Pause Download</button>
-        <button id="resume-button" onclick="resumeDownload()" style="display: none;">Resume Download</button>
-        <button id="back-button" onclick="window.location.href='/'">Back to Index</button>
+        <button id="abort-button">Abort Download</button>
+        <button id="pause-button">Pause Download</button>
+        <button id="resume-button">Resume Download</button>
+        <button id="toggle-console">Toggle Console View</button>
+        <button id="back-button">Back to Index</button>
    </div>
-    <script>
+    <div id="console"></div>
+    <script nonce="{{.Nonce}}">
        let isPaused = false;
+        const filename = "{{.Filename}}";
+        const authToken = "{{.AuthToken}}";
+
+        function withToken(path) {
+            if (!authToken) {
+                return path;
+            }
+
+            const separator = path.includes('?') ? '&' : '?';
+            return `${path}${separator}token=${authToken}`;
+        }

        function updateProgress() {
-            fetch('/progress?filename={{.Filename}}', {
+            fetch(withToken(`/progress?filename=${encodeURIComponent(filename)}`), {
                headers: {
                    'Accept': 'application/json'
                }
@@ -166,7 +190,7 @@
        }

        function abortDownload() {
-            fetch('/abort?filename={{.Filename}}', { method: 'POST' })
+            fetch(withToken(`/abort?filename=${encodeURIComponent(filename)}`), { method: 'POST' })
                .then(response => {
                    if (response.ok) {
                        console.log('Abort signal sent. The download will stop soon.');
@@ -177,7 +201,7 @@
        }

        function pauseDownload() {
-            fetch('/pause?filename={{.Filename}}', { method: 'POST' })
+            fetch(withToken(`/pause?filename=${encodeURIComponent(filename)}`), { method: 'POST' })
                .then(response => {
                    if (response.ok) {
                        console.log('Pause signal sent. The download will pause soon.');
@@ -190,7 +214,7 @@
        }

        function resumeDownload() {
-            fetch('/resume?filename={{.Filename}}', { method: 'POST' })
+            fetch(withToken(`/resume?filename=${encodeURIComponent(filename)}`), { method: 'POST' })
                .then(response => {
                    if (response.ok) {
                        console.log('Resume signal sent. The download will resume soon.');
@@ -203,6 +227,35 @@
                });
        }

+        const consoleDiv = document.getElementById('console');
+        const protocol = window.location.protocol === 'https:' ? 'wss:' : 'ws:';
+        const ws = new WebSocket(`${protocol}//${window.location.host}${withToken(`/ws?filename=${encodeURIComponent(filename)}`)}`);
+
+        ws.onmessage = function(event) {
+            consoleDiv.textContent += event.data; 
+            consoleDiv.scrollTop = consoleDiv.scrollHeight; 
+        };
+
+        ws.onclose = function() {
+            console.log('WebSocket connection closed');
+        };
+
+        ws.onerror = function(error) {
+            console.error('WebSocket error:', error);
+        };
+
+        document.addEventListener('DOMContentLoaded', function() {
+            document.getElementById('abort-button').addEventListener('click', abortDownload);
+            document.getElementById('pause-button').addEventListener('click', pauseDownload);
+            document.getElementById('resume-button').addEventListener('click', resumeDownload);
+            document.getElementById('back-button').addEventListener('click', function() {
+                window.location.href = withToken('/');
+            });
+            document.getElementById('toggle-console').addEventListener('click', function() {
+                consoleDiv.style.display = consoleDiv.style.display === "none" ? "block" : "none";
+            });
+        });
+
        updateProgress();
    </script>
 </body>
--- a/src/templates/select
+++ b/src/templates/select
@@ -4,14 +4,14 @@
    <meta charset="UTF-8">
    <meta name="viewport" content="width=device-width, initial-scale=1.0">
    <title>Select Items to Download</title>
-    <style>
+    <style nonce="{{.Nonce}}">
        body {
            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
            background-color: #1e1e1e;
            color: #d4d4d4;
            line-height: 1.6;
            padding: 20px;
-            max-width: 800px;
+            max-width: 900px;
            margin: 0 auto;
            box-sizing: border-box;
        }
@@ -50,20 +50,33 @@
        button:hover, input[type="submit"]:hover {
            background-color: #45a049;
        }
+        #fix-order-button {
+            background-color: #2196F3;
+            color: white;
+            border: none;
+            padding: 10px 15px;
+            margin: 5px;
+            border-radius: 4px;
+            cursor: pointer;
+        }
+        #fix-order-button:hover {
+            background-color: #1976D2;
+        }
    </style>
 </head>
 <body>
    <h1>Select Items to Download</h1>
-    <form action="/process" method="post">
+    <form action="{{if .AuthToken}}/process?token={{.AuthToken}}{{else}}/process{{end}}" method="post">
        <input type="hidden" name="filenames" value="{{.Filenames}}">
        {{range $filename, $fileItems := .AllItems}}
            <h2>{{$filename}}</h2>
            {{range $season, $items := $fileItems}}
-                <div class="season">
+                <div class="season" id="season-{{$filename}}-{{$season}}">
                    <div class="season-title">
-                        <input type="checkbox" class="season-checkbox" id="season-{{$filename}}-{{$season}}" checked onchange="toggleSeason('{{$filename}}-{{$season}}')">
-                        <label for="season-{{$filename}}-{{$season}}">{{$season}}</label>
+                        <input type="checkbox" class="season-checkbox" id="season-checkbox-{{$filename}}-{{$season}}" data-season-key="{{$filename}}-{{$season}}" checked>
+                        <label for="season-checkbox-{{$filename}}-{{$season}}">{{$season}}</label>
                    </div>
+                    <div class="season-items">
                    {{range $item := $items}}
                        <div class="item">
                            <label>
@@ -72,16 +85,17 @@
                            </label>
                        </div>
                    {{end}}
+                    </div>
                </div>
            {{end}}
        {{end}}
        <div>
-            <button type="button" onclick="selectAll(true)">Select All</button>
-            <button type="button" onclick="selectAll(false)">Select None</button>
+            <button type="button" id="select-all">Select All</button>
+            <button type="button" id="select-none">Select None</button>
            <input type="submit" value="Start Download">
        </div>
    </form>
-    <script>
+    <script nonce="{{.Nonce}}">
        function selectAll(checked) {
            var checkboxes = document.getElementsByName('items');
            for (var i = 0; i < checkboxes.length; i++) {
@@ -94,12 +108,23 @@
        }

        function toggleSeason(season) {
-            var seasonCheckbox = document.getElementById('season-' + season);
+            var seasonCheckbox = document.getElementById('season-checkbox-' + season);
            var episodeCheckboxes = document.getElementsByClassName('episode-' + season);
            for (var i = 0; i < episodeCheckboxes.length; i++) {
                episodeCheckboxes[i].checked = seasonCheckbox.checked;
            }
        }
+
+        document.addEventListener('DOMContentLoaded', function() {
+            document.getElementById('select-all').addEventListener('click', function() { selectAll(true); });
+            document.getElementById('select-none').addEventListener('click', function() { selectAll(false); });
+            var boxes = document.getElementsByClassName('season-checkbox');
+            for (var i = 0; i < boxes.length; i++) {
+                boxes[i].addEventListener('change', function() {
+                    toggleSeason(this.dataset.seasonKey);
+                });
+            }
+        });
    </script>
 </body>
 </html>
--- a/src/utils.go
+++ b/src/utils.go
@@ -2,6 +2,7 @@ package main

 import (
 	"encoding/json"
+	"errors"
 	"fmt"
 	"io"
 	"net/url"
@@ -9,6 +10,7 @@ import (
 	"os/exec"
 	"path/filepath"
 	"regexp"
+	"sort"
 	"strconv"
 	"strings"
 	"sync"
@@ -20,23 +22,131 @@ type JobInfo struct {
 	AbortChan  chan struct{}
 	ResumeChan chan struct{}
 	Cmd        *exec.Cmd
-	Paused     bool
 	TempDir    string
+
+	mu        sync.RWMutex
+	paused    bool
+	abortOnce sync.Once
+}
+
+func NewJobInfo() *JobInfo {
+	return &JobInfo{
+		AbortChan:  make(chan struct{}),
+		ResumeChan: make(chan struct{}, 1),
+	}
+}
+
+func (j *JobInfo) SetPaused(value bool) {
+	j.mu.Lock()
+	defer j.mu.Unlock()
+	j.paused = value
+}
+
+func (j *JobInfo) IsPaused() bool {
+	j.mu.RLock()
+	defer j.mu.RUnlock()
+	return j.paused
+}
+
+func (j *JobInfo) SetCmd(cmd *exec.Cmd) {
+	j.mu.Lock()
+	defer j.mu.Unlock()
+	j.Cmd = cmd
+}
+
+func (j *JobInfo) SetTempDir(tempDir string) {
+	j.mu.Lock()
+	defer j.mu.Unlock()
+	j.TempDir = tempDir
+}
+
+func (j *JobInfo) GetTempDir() string {
+	j.mu.RLock()
+	defer j.mu.RUnlock()
+	return j.TempDir
+}
+
+func (j *JobInfo) KillProcess() {
+	j.mu.RLock()
+	cmd := j.Cmd
+	j.mu.RUnlock()
+
+	if cmd != nil && cmd.Process != nil {
+		_ = cmd.Process.Kill()
+	}
+}
+
+func (j *JobInfo) SignalResume() {
+	select {
+	case j.ResumeChan <- struct{}{}:
+	default:
+	}
+}
+
+func (j *JobInfo) Abort() {
+	j.abortOnce.Do(func() {
+		close(j.AbortChan)
+	})
+}
+
+func (j *JobInfo) IsAborted() bool {
+	select {
+	case <-j.AbortChan:
+		return true
+	default:
+		return false
+	}
 }

 var (
-	jobsMutex sync.Mutex
-	jobs      = make(map[string]*JobInfo)
+	ErrDownloadPaused  = errors.New("download paused")
+	ErrDownloadAborted = errors.New("download aborted")
 )

+var sanitizeFilenameRegex = regexp.MustCompile(`[<>:"/\\|?*\x00-\x1f]`)
+
+var windowsReservedNames = map[string]struct{}{
+	"CON": {}, "PRN": {}, "AUX": {}, "NUL": {},
+	"COM1": {}, "COM2": {}, "COM3": {}, "COM4": {}, "COM5": {}, "COM6": {}, "COM7": {}, "COM8": {}, "COM9": {},
+	"LPT1": {}, "LPT2": {}, "LPT3": {}, "LPT4": {}, "LPT5": {}, "LPT6": {}, "LPT7": {}, "LPT8": {}, "LPT9": {},
+}
+
 func sanitizeFilename(filename string) string {
-	filename = regexp.MustCompile(`[<>:"/\\|?*]`).ReplaceAllString(filename, "_")
+	filename = sanitizeFilenameRegex.ReplaceAllString(filename, "_")
+	filename = strings.Trim(filename, ". ")

-	filename = strings.Trim(filename, ".")
+	base := filename
+	if idx := strings.LastIndex(filename, "."); idx > 0 {
+		base = filename[:idx]
+	}
+	if _, reserved := windowsReservedNames[strings.ToUpper(base)]; reserved {
+		filename = "_" + filename
+	}

+	if filename == "" {
+		filename = "_"
+	}
 	return filename
 }

+func safeUploadPath(filename string) (string, error) {
+	cleanName := strings.TrimSpace(filename)
+	if cleanName == "" {
+		return "", fmt.Errorf("filename is required")
+	}
+
+	baseName := filepath.Base(cleanName)
+	if baseName != cleanName {
+		return "", fmt.Errorf("invalid filename")
+	}
+
+	if strings.Contains(baseName, "..") {
+		return "", fmt.Errorf("invalid filename")
+	}
+
+	return filepath.Join(uploadDir, baseName), nil
+}
+
 func isValidURL(toTest string) bool {
 	_, err := url.ParseRequestURI(toTest)
 	return err == nil
@@ -184,64 +294,116 @@ func groupItemsBySeason(items []Item) map[string][]Item {
 }

 func filterSelectedItems(items []Item, selectedItems []string) []Item {
-	var filtered []Item
+	set := make(map[string]struct{}, len(selectedItems))
+	for _, s := range selectedItems {
+		set[s] = struct{}{}
+	}
+	filtered := make([]Item, 0, len(selectedItems))
 	for _, item := range items {
-		for _, selected := range selectedItems {
-			if item.Filename == selected {
-				filtered = append(filtered, item)
-				break
-			}
+		if _, ok := set[item.Filename]; ok {
+			filtered = append(filtered, item)
 		}
 	}
 	return filtered
 }

-func processItems(filename string, items []Item) error {
-	jobsMutex.Lock()
-	jobInfo := &JobInfo{
-		AbortChan:  make(chan struct{}),
-		ResumeChan: make(chan struct{}),
+func sortItems(items []Item) {
+	sort.Slice(items, func(i, j int) bool {
+		iMeta := parseMetadata(items[i].Metadata)
+		jMeta := parseMetadata(items[j].Metadata)
+
+		if iMeta.Title != jMeta.Title {
+			return iMeta.Title < jMeta.Title
+		}
+
+		iSeason := extractNumber(iMeta.Season)
+		jSeason := extractNumber(jMeta.Season)
+
+		if iSeason != jSeason {
+			return iSeason < jSeason
+		}
+
+		iEpisode := extractEpisodeNumber(items[i].Filename)
+		jEpisode := extractEpisodeNumber(items[j].Filename)
+
+		return iEpisode < jEpisode
+	})
+}
+
+func extractNumber(s string) int {
+	num, _ := strconv.Atoi(strings.TrimLeft(s, "S"))
+	return num
+}
+
+var episodeNumberRegex = regexp.MustCompile(`(?i)S\d+E(\d+)`)
+
+func extractEpisodeNumber(filename string) int {
+	match := episodeNumberRegex.FindStringSubmatch(filename)
+	if len(match) < 2 {
+		return 0
 	}
-	jobs[filename] = jobInfo
-	jobsMutex.Unlock()
+	num, _ := strconv.Atoi(match[1])
+	return num
+}
+
+func processItems(filename string, items []Item) error {
+	jobInfo := NewJobInfo()
+	setJob(filename, jobInfo)

 	defer func() {
-		jobsMutex.Lock()
-		delete(jobs, filename)
-		jobsMutex.Unlock()
+		removeJob(filename)

-		if jobInfo.TempDir != "" {
-			os.RemoveAll(jobInfo.TempDir)
+		tempDir := jobInfo.GetTempDir()
+		if tempDir != "" {
+			_ = os.RemoveAll(tempDir)
 		}
 	}()

+	sortItems(items)
+
 	for i := 0; i < len(items); i++ {
 		select {
 		case <-jobInfo.AbortChan:
-			updateProgress(filename, 100, "Aborted")
-			return fmt.Errorf("download aborted")
+			updateProgress(filename, 100, "Aborted", "aborted")
+			logger.LogJobState(filename, "aborted")
+			return ErrDownloadAborted
 		default:
-			if jobInfo.Paused {
+			if jobInfo.IsPaused() {
 				select {
 				case <-jobInfo.ResumeChan:
-					jobInfo.Paused = false
+					jobInfo.SetPaused(false)
+					logger.LogJobState(filename, "resumed")
 				case <-jobInfo.AbortChan:
-					updateProgress(filename, 100, "Aborted")
-					return fmt.Errorf("download aborted")
+					updateProgress(filename, 100, "Aborted", "aborted")
+					logger.LogJobState(filename, "aborted")
+					return ErrDownloadAborted
 				}
 			}
-			updateProgress(filename, float64(i)/float64(len(items))*100, items[i].Filename)
-			err := downloadFile(items[i], jobInfo)
+			updateProgress(filename, float64(i)/float64(len(items))*100, items[i].Filename, "running")
+			err := downloadFile(filename, items[i], jobInfo)
 			if err != nil {
-				if err.Error() == "download paused" {
-					removeCompletedEpisodes(filename, items[:i])
+				if errors.Is(err, ErrDownloadPaused) {
+					logger.LogJobState(filename, "paused")
+					if remErr := removeCompletedEpisodes(filename, items[:i]); remErr != nil {
+						logger.LogError("Process Items", fmt.Sprintf("Error updating partial progress file: %v", remErr))
+					}
 					i--
 					continue
 				}
+				if errors.Is(err, ErrDownloadAborted) {
+					updateProgress(filename, 100, "Aborted", "aborted")
+					logger.LogJobState(filename, "aborted")
+					return ErrDownloadAborted
+				}
+
+				updateProgress(filename, float64(i)/float64(len(items))*100, items[i].Filename, "failed")
+				logger.LogError("Process Items", fmt.Sprintf("Error downloading item %s: %v", items[i].Filename, err))
+				return fmt.Errorf("error downloading %s: %w", items[i].Filename, err)
 			}
 		}
 	}
-	updateProgress(filename, 100, "")
+	updateProgress(filename, 100, "", "completed")
+	logger.LogJobState(filename, "completed successfully")
 	return nil
 }

--- a/src/watcher.go
+++ b/src/watcher.go
@@ -0,0 +1,187 @@
+package main
+
+import (
+	"fmt"
+	"io"
+	"os"
+	"path/filepath"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/fsnotify/fsnotify"
+)
+
+func watchFolder() {
+	if config.WatchFolder.UsePolling {
+		go pollFolder()
+	}
+
+	if config.WatchFolder.UseInotify {
+		go inotifyWatch()
+	}
+}
+
+var watchedProcessing = struct {
+	mu    sync.Mutex
+	files map[string]bool
+}{files: make(map[string]bool)}
+
+func beginWatching(filePath string) bool {
+	watchedProcessing.mu.Lock()
+	defer watchedProcessing.mu.Unlock()
+	if watchedProcessing.files[filePath] {
+		return false
+	}
+	watchedProcessing.files[filePath] = true
+	return true
+}
+
+func doneWatching(filePath string) {
+	watchedProcessing.mu.Lock()
+	defer watchedProcessing.mu.Unlock()
+	delete(watchedProcessing.files, filePath)
+}
+
+func inotifyWatch() {
+	watcher, err := fsnotify.NewWatcher()
+	if err != nil {
+		logger.LogError("Watcher", fmt.Sprintf("Failed to create inotify watcher: %v", err))
+		return
+	}
+	defer watcher.Close()
+
+	done := make(chan bool)
+
+	go func() {
+		for {
+			select {
+			case event, ok := <-watcher.Events:
+				if !ok {
+					return
+				}
+				if event.Op&fsnotify.Create == fsnotify.Create {
+					if strings.HasSuffix(event.Name, ".drmd") {
+						logger.LogInfo("Watcher", fmt.Sprintf("New .drmd detected: %s", event.Name))
+						go processWatchedFile(event.Name)
+					}
+				}
+			case err, ok := <-watcher.Errors:
+				if !ok {
+					return
+				}
+				logger.LogError("Watcher", fmt.Sprintf("Inotify error: %v", err))
+			}
+		}
+	}()
+
+	err = watcher.Add(config.WatchFolder.Path)
+	if err != nil {
+		logger.LogError("Watcher", fmt.Sprintf("Failed to add watch folder %s: %v", config.WatchFolder.Path, err))
+		return
+	}
+	<-done
+}
+
+func pollFolder() {
+	ticker := time.NewTicker(time.Duration(config.WatchFolder.PollingInterval) * time.Second)
+	defer ticker.Stop()
+
+	for range ticker.C {
+		files, err := filepath.Glob(filepath.Join(config.WatchFolder.Path, "*.drmd"))
+		if err != nil {
+			logger.LogError("Watcher", fmt.Sprintf("Error polling folder: %v", err))
+			continue
+		}
+
+		for _, file := range files {
+			logger.LogInfo("Watcher", fmt.Sprintf("New .drmd detected via polling: %s", file))
+			go processWatchedFile(file)
+		}
+	}
+}
+
+func processWatchedFile(filePath string) {
+	if !beginWatching(filePath) {
+		return
+	}
+	releaseDedupe := true
+	defer func() {
+		if releaseDedupe {
+			doneWatching(filePath)
+		}
+	}()
+
+	for {
+		initialSize, err := getFileSize(filePath)
+		if err != nil {
+			logger.LogError("Watcher", fmt.Sprintf("Error getting file size: %v", err))
+			return
+		}
+
+		time.Sleep(1 * time.Second)
+
+		currentSize, err := getFileSize(filePath)
+		if err != nil {
+			logger.LogError("Watcher", fmt.Sprintf("Error getting file size: %v", err))
+			return
+		}
+
+		if initialSize == currentSize {
+			break
+		}
+	}
+
+	file, err := os.Open(filePath)
+	if err != nil {
+		logger.LogError("Watcher", fmt.Sprintf("Error opening file: %v", err))
+		return
+	}
+	defer file.Close()
+
+	originalFilename := filepath.Base(filePath)
+	tempFile, err := os.CreateTemp(uploadDir, originalFilename)
+	if err != nil {
+		logger.LogError("Watcher", fmt.Sprintf("Error creating temporary file: %v", err))
+		return
+	}
+
+	if _, err := io.Copy(tempFile, file); err != nil {
+		_ = tempFile.Close()
+		_ = os.Remove(tempFile.Name())
+		logger.LogError("Watcher", fmt.Sprintf("Error copying file: %v", err))
+		return
+	}
+	if err := tempFile.Close(); err != nil {
+		_ = os.Remove(tempFile.Name())
+		logger.LogError("Watcher", fmt.Sprintf("Error closing temp file: %v", err))
+		return
+	}
+
+	if err := os.Remove(filePath); err != nil {
+		logger.LogError("Watcher", fmt.Sprintf("Error deleting original file; keeping dedupe entry to avoid reprocessing: %v", err))
+		_ = os.Remove(tempFile.Name())
+		releaseDedupe = false
+		return
+	}
+
+	items, err := parseInputFile(tempFile.Name())
+	if err != nil {
+		logger.LogError("Watcher", fmt.Sprintf("Error parsing input file: %v", err))
+		return
+	}
+
+	go func(targetFilename string, targetItems []Item) {
+		if err := processItems(targetFilename, targetItems); err != nil {
+			logger.LogError("Watcher", fmt.Sprintf("Error processing watched file %s: %v", targetFilename, err))
+		}
+	}(filepath.Base(tempFile.Name()), items)
+}
+
+func getFileSize(filePath string) (int64, error) {
+	fileInfo, err := os.Stat(filePath)
+	if err != nil {
+		return 0, err
+	}
+	return fileInfo.Size(), nil
+}
--- a/subtitles.go
+++ b/subtitles.go
@@ -1,60 +0,0 @@
-package main
-
-import (
-	"fmt"
-	"io"
-	"net/http"
-	"os"
-	"strings"
-
-	"github.com/asticode/go-astisub"
-)
-
-func downloadAndConvertSubtitles(subtitlesURLs string) ([]string, error) {
-	var subtitlePaths []string
-	urls := strings.Split(subtitlesURLs, ",")
-
-	for _, url := range urls {
-		vttPath, err := downloadSubtitle(url)
-		if err != nil {
-			return nil, fmt.Errorf("error downloading subtitle: %v", err)
-		}
-
-		srtPath, err := convertVTTtoSRT(vttPath)
-		if err != nil {
-			return nil, fmt.Errorf("error converting subtitle: %v", err)
-		}
-
-		subtitlePaths = append(subtitlePaths, srtPath)
-	}
-
-	return subtitlePaths, nil
-}
-
-func downloadSubtitle(url string) (string, error) {
-	resp, err := http.Get(url)
-	if err != nil {
-		return "", err
-	}
-	defer resp.Body.Close()
-
-	tempFile, err := os.CreateTemp("", "subtitle_*.vtt")
-	if err != nil {
-		return "", err
-	}
-	defer tempFile.Close()
-
-	_, err = io.Copy(tempFile, resp.Body)
-	if err != nil {
-		return "", err
-	}
-
-	return tempFile.Name(), nil
-}
-
-func convertVTTtoSRT(vttPath string) (string, error) {
-	srtPath := strings.TrimSuffix(vttPath, ".vtt") + ".srt"
-	s1, _ := astisub.OpenFile(vttPath)
-	s1.Write(srtPath)
-	return srtPath, nil
-}
--- a/templates/index
+++ b/templates/index
@@ -1,152 +0,0 @@
-<!DOCTYPE html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8">
-    <meta name="viewport" content="width=device-width, initial-scale=1.0">
-    <title>Simple Downloader</title>
-    <style>
-        body {
-            font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', Roboto, Helvetica, Arial, sans-serif;
-            background-color: #1e1e1e;
-            color: #d4d4d4;
-            line-height: 1.6;
-            padding: 20px;
-            max-width: 800px;
-            margin: 0 auto;
-            box-sizing: border-box;
-        }
-        h1, h2 {
-            border-bottom: 1px solid #333;
-            padding-bottom: 10px;
-            word-wrap: break-word;
-        }
-        form {
-            margin-bottom: 20px;
-            display: flex;
-            flex-direction: column;
-        }
-        input[type="file"], input[type="submit"] {
-            background-color: #2d2d2d;
-            color: #d4d4d4;
-            border: 1px solid #444;
-            padding: 8px 12px;
-            border-radius: 4px;
-            margin-bottom: 10px;
-            max-width: 100%;
-        }
-        input[type="submit"] {
-            cursor: pointer;
-            background-color: #4CAF50;
-            color: white;
-        }
-        input[type="submit"]:hover {
-            background-color: #45a049;
-        }
-        ul {
-            list-style-type: none;
-            padding: 0;
-            margin-bottom: 10px; 
-        }
-        li {
-            background-color: #2d2d2d;
-            margin-bottom: 10px;
-            padding: 10px;
-            border-radius: 4px;
-            word-wrap: break-word;
-        }
-        .job-title {
-            font-size: 1.1em;
-            font-weight: bold;
-            margin-bottom: 5px;
-        }
-        .job-title a {
-            color: #58a6ff;
-            text-decoration: none;
-        }
-        .job-title a:hover {
-            text-decoration: underline;
-        }
-        .job-info {
-            font-size: 0.9em;
-            color: #a0a0a0;
-        }
-        .progress-text {
-            display: inline-block;
-            width: 5em;
-        }
-        .paused {
-            color: #ffa500;
-        }
-        @media (max-width: 600px) {
-            body {
-                padding: 10px;
-            }
-            h1, h2 {
-                font-size: 1.5em;
-            }
-            input[type="file"], input[type="submit"] {
-                font-size: 16px;
-            }
-            input[type="submit"], #clear-completed {
-                font-size: 16px;
-            }
-        }
-        input[type="submit"], #clear-completed {
-            cursor: pointer;
-            color: white;
-            border: 1px solid #444;
-            padding: 8px 12px;
-            border-radius: 4px;
-            margin-bottom: 10px;
-            max-width: 100%;
-            width: 100%;
-        }
-        #clear-completed {
-            background-color: #f44336;
-        }
-        #clear-completed:hover {
-            background-color: #d32f2f;
-        }
-    </style>
-</head>
-<body>
-    <h1>Simple Downloader</h1>
-    <form action="/upload" method="post" enctype="multipart/form-data">
-        <input type="file" name="files" accept=".drmd" multiple>
-        <input type="submit" value="Upload and Process">
-    </form>
-    <h2>Currently Running Jobs</h2>
-    <ul>
-        {{range $filename, $info := .Jobs}}
-            <li>
-                <div class="job-title">
-                    <a href="/progress?filename={{$filename}}">{{$filename}}</a>
-                </div>
-                <div class="job-info">
-                    Progress: <span class="progress-text">{{printf "%5.1f%%" $info.Percentage}}</span>
-                    Current file: {{$info.CurrentFile}}
-                    {{if $info.Paused}}
-                        <span class="paused">(Paused)</span>
-                    {{end}}
-                </div>
-            </li>
-        {{else}}
-            <li>No active jobs</li>
-        {{end}}
-    </ul>
-    <button id="clear-completed" onclick="clearCompleted()">Clear Completed Jobs</button>
-    <script>
-        function clearCompleted() {
-            fetch('/clear-completed', { method: 'POST' })
-                .then(response => response.json())
-                .then(data => {
-                    if (data.success) {
-                        location.reload();
-                    } else {
-                        alert('Failed to clear completed jobs');
-                    }
-                });
-        }
-    </script>
-</body>
-</html>
Author	SHA1	Message	Date
toor	070d4a862c	Fix stream selection flags for bytohgn fork	2026-04-14 11:07:58 +02:00
Joren	6543d3a170	Merge pull request 'bugfixes' (#12 ) from bugfixes into main Reviewed-on: #12	2026-04-14 10:26:04 +02:00
Joren	0e08b1669c	Merge branch 'main' into bugfixes	2026-04-14 10:25:53 +02:00
Joren	f4310ed688	Simplify logger output format Drop source file/line prefixes from logs so console output is cleaner and easier to scan during long-running jobs.	2026-04-14 10:21:21 +02:00
Joren	1c82b619c4	Harden web/download pipeline and split handler modules Replace shell-based downloader execution with validated arguments, enforce request hardening and safer defaults, and refactor handlers/router/state so job control is safer and easier to maintain.	2026-04-14 10:21:11 +02:00
Joren	6e016b802b	ye	2025-06-01 19:44:24 +02:00
Joren	78ed401392	Merge pull request 'bugfixes' (#11 ) from bugfixes into main Reviewed-on: #11	2025-05-21 09:45:11 +02:00
Joren	72b85ec281	Add template	2025-05-21 09:44:20 +02:00
Joren	b2e3268ad1	Stop tracking config.toml	2025-05-21 09:42:35 +02:00
Joren	1af43b111c	enclose MPD url	2025-05-21 09:40:45 +02:00
Joren	03312a0079	Fix accidentally registering same handler twice	2024-12-31 01:50:58 +01:00
Joren	a91163f845	config	2024-12-30 16:57:05 +01:00
Joren	7d28d1cea8	Merge pull request 'speedLimiter' (#10 ) from speedLimiter into main Reviewed-on: #10	2024-12-30 16:47:45 +01:00
Joren	3fda737af2	Merge branch 'main' into speedLimiter	2024-12-30 16:47:21 +01:00
Joren	8cf3d4dda8	Show limit	2024-12-30 16:46:30 +01:00
Joren	2e18921a27	Show limit	2024-12-30 16:45:56 +01:00
Joren	f1efb1d67c	impl speed limit	2024-12-30 16:32:12 +01:00
Joren	457ede5b62	Speed	2024-12-30 16:20:48 +01:00
Joren	7eb724d01f	Speed	2024-12-30 16:16:51 +01:00
Joren	189bbb0874	Speed	2024-12-30 16:16:37 +01:00
Joren	68da5f9658	Speed	2024-12-30 16:16:21 +01:00
Joren	83cd0b722b	style	2024-12-30 16:04:37 +01:00
Joren	ca176e1a76	Update README.md	2024-10-07 13:02:40 +02:00
Joren	54656f2630	Update README.md	2024-10-07 13:02:17 +02:00
Joren	f38b0c69d9	Merge pull request 'Poller' (#9 ) from Poller into main Reviewed-on: #9	2024-10-07 12:59:18 +02:00
Joren	b1ba08933a	Console should also beable to be controlled by env var	2024-10-07 12:48:37 +02:00
Joren	a049610291	Implement polling, update readme	2024-10-07 12:46:38 +02:00
Joren	c46538a55f	Change the config paths according to new layout	2024-10-07 12:46:26 +02:00
Joren	fe6b7c78f6	Add options for polling, path validation, env variables	2024-10-07 12:45:49 +02:00
Joren	f9c2ac64d7	Merge pull request 'watchFolder' (#8 ) from watchFolder into main Reviewed-on: #8	2024-10-06 22:45:52 +02:00
Joren	1f42b2a877	Update README.md	2024-10-06 22:45:33 +02:00
Joren	e03226a7ee	Make sure the file is fully written	2024-10-06 00:37:47 +02:00
Joren	f1015ab62e	Change watched file name	2024-10-06 00:14:46 +02:00
Joren	acf172933d	Watcher	2024-10-06 00:09:43 +02:00
Joren	99f75f1cd1	Change the wss if https	2024-09-25 15:47:39 +02:00
Joren	c7712982f3	Merge pull request 'Implement a live console of the downloader on the progress page' (#6 ) from implConsole into main Reviewed-on: #6	2024-09-24 20:40:17 +02:00
Joren	bf78384fa8	Update readme	2024-09-24 20:33:20 +02:00
Joren	7445627f7e	Add option to disable the console broadcasts	2024-09-24 15:17:58 +02:00
Joren	cc28f0f3c2	Correctly split console for each process	2024-09-24 15:01:09 +02:00
Joren	ace79838fe	Make page a bit wider to account for console	2024-09-23 17:26:33 +02:00
Joren	8a63f73839	Fix: Console display should be set to none	2024-09-23 17:24:03 +02:00
Joren	da03138d5c	Implement logging, console window	2024-09-23 17:23:22 +02:00
Joren	0bae45a824	Display Console	2024-09-23 16:50:04 +02:00
Joren	7159bae9f7	Basic tests	2024-09-15 05:11:00 +02:00
Joren	5b6e1e6b01	Delete src/templates/stats	2024-09-15 05:02:02 +02:00
Joren	4b03c7c59b	Change project structure	2024-09-15 05:00:02 +02:00
Joren	1dd8aa594d	Add images for docxs	2024-09-15 04:40:14 +02:00
Joren	72889d3083	Sort episodes in a holy way	2024-09-15 04:29:48 +02:00
Joren	bd87baa40a	Makefile	2024-09-15 00:34:25 +02:00
Joren	2f738413f3	H	2024-09-15 00:31:46 +02:00