Add standalone desktop workflow

.gitignore

@@ -27,7 +27,9 @@ go.work.sum
 
 # Build output
 /jukebox
+/release/
+/.tmp/
+/.gocache/
 
 # Temp copy files
 *.juketmp
-

Makefile

@@ -0,0 +1,51 @@
+APP := jukebox
+APP_PKG := ./cmd/jukebox
+APP_URL := http://127.0.0.1:8080
+
+ROOT_DIR := $(CURDIR)
+DEV_DIR := $(ROOT_DIR)/.tmp
+CONFIG_DIR := $(DEV_DIR)/config
+MEDIA_DIR := $(DEV_DIR)/media
+MOUNT_DIR := $(DEV_DIR)/mount
+CONFIG_PATH := $(CONFIG_DIR)/config.json
+GOCACHE_DIR := $(DEV_DIR)/gocache
+
+.PHONY: run test build release dev-dirs
+
+dev-dirs:
+	mkdir -p "$(CONFIG_DIR)" "$(MEDIA_DIR)" "$(MOUNT_DIR)" "$(GOCACHE_DIR)"
+
+run: dev-dirs
+	@sh -c '\
+		url="$(APP_URL)"; \
+		open_url() { \
+			if command -v open >/dev/null 2>&1; then \
+				open "$$1"; \
+			elif command -v powershell >/dev/null 2>&1; then \
+				powershell -NoProfile -Command "Start-Process '\''$$1'\''" >/dev/null; \
+			elif command -v xdg-open >/dev/null 2>&1; then \
+				xdg-open "$$1" >/dev/null 2>&1; \
+			fi; \
+		}; \
+		for _ in 1 2 3 4 5 6 7 8 9 10 11 12 13 14 15; do \
+			if curl -fsS "$$url/health" >/dev/null 2>&1; then \
+				open_url "$$url"; \
+				exit 0; \
+			fi; \
+			sleep 1; \
+		done \
+	' &
+	GOCACHE="$(GOCACHE_DIR)" go run $(APP_PKG) \
+		-config "$(CONFIG_PATH)" \
+		-media "$(MEDIA_DIR)" \
+		-mount "$(MOUNT_DIR)" \
+		-addr ":8080"
+
+test: dev-dirs
+	GOCACHE="$(GOCACHE_DIR)" go test ./...
+
+build: dev-dirs
+	GOCACHE="$(GOCACHE_DIR)" go build -o "$(ROOT_DIR)/$(APP)" $(APP_PKG)
+
+release:
+	./ops/build-release.sh

cmd/jukebox/main.go

@@ -3,6 +3,7 @@ package main
 import (
 	"context"
 	"encoding/json"
+	"errors"
 	"flag"
 	"log"
 	"net/http"
@@ -33,6 +34,9 @@ func main() {
 	if err != nil {
 		log.Fatalf("load config: %v", err)
 	}
+	if cfg.MediaPath == "" {
+		cfg.MediaPath = config.NormalizeMediaPath(*mediaPath)
+	}
 
 	taskStore := task.NewStore()
 	cp := copier.New(taskStore)
@@ -123,7 +127,7 @@ func main() {
 		case disk.DiskKnown:
 			openDiskDB(ev.Info)
 			if watcherReady && ev.Prev.State != disk.DiskKnown && cfg.AutoCopy {
-				triggerAutoCopy(cp, cfg, ev.Info, *mediaPath)
+				triggerAutoCopy(cp, cfg, ev.Info)
 			}
 		case disk.DiskForeign:
 			closeDiskDB(ev.Prev)
@@ -134,6 +138,21 @@ func main() {
 	w.ProbeNow()
 	watcherReady = true
 
+	probeDisk := func(mountPath string) (disk.DiskInfo, error) {
+		mountPath = config.NormalizeMediaPath(mountPath)
+		if mountPath == "" {
+			return disk.DiskInfo{}, errors.New("mount_path is required")
+		}
+		info, err := disk.Probe(mountPath)
+		if err != nil {
+			return info, err
+		}
+		if info.State == disk.DiskKnown {
+			openDiskDB(info)
+		}
+		return info, nil
+	}
+
 	srv, err := api.New(api.Deps{
 		Config:     cfg,
 		ConfigPath: *configPath,
@@ -141,8 +160,7 @@ func main() {
 		Watcher:    w,
 		Copier:     cp,
 		Tasks:      taskStore,
-		MediaPath:  *mediaPath,
+		ProbeDisk:  probeDisk,
-		MountPath:  *mountPath,
 		OnDiskInit: func(mountPath, diskID string) {
 			openDiskDB(disk.DiskInfo{
 				State:     disk.DiskKnown,
@@ -178,7 +196,7 @@ func main() {
 	}
 }
 
-func triggerAutoCopy(cp *copier.Copier, cfg *config.Config, info disk.DiskInfo, mediaPath string) {
+func triggerAutoCopy(cp *copier.Copier, cfg *config.Config, info disk.DiskInfo) {
 	hasEnabledSources := false
 	for _, s := range cfg.Sources {
 		if s.Enabled {
@@ -193,7 +211,7 @@ func triggerAutoCopy(cp *copier.Copier, cfg *config.Config, info disk.DiskInfo,
 		_, err := cp.Start(context.Background(), copier.Options{
 			DiskID:         info.DiskID,
 			MountPath:      info.MountPath,
-			MediaPath:      mediaPath,
+			MediaPath:      cfg.MediaPath,
 			DestFolder:     cfg.DestFolder,
 			SourceRules:    cfg.Sources,
 			ReserveFreeGB:  cfg.ReserveFreeGB,

internal/api/handlers_copy.go

@@ -12,6 +12,47 @@ import (
 	"jukebox_maker/internal/disk"
 )
 
+func (s *Server) copyOptions(cfg *config.Config, diskInfo disk.DiskInfo, overwriteMode config.OverwriteMode) copier.Options {
+	return copier.Options{
+		DiskID:         diskInfo.DiskID,
+		MountPath:      diskInfo.MountPath,
+		MediaPath:      cfg.MediaPath,
+		DestFolder:     cfg.DestFolder,
+		SourceRules:    cfg.Sources,
+		ReserveFreeGB:  cfg.ReserveFreeGB,
+		OverwriteMode:  overwriteMode,
+		FileSelectMode: cfg.FileSelectMode,
+	}
+}
+
+func hasEnabledSources(cfg *config.Config) bool {
+	for _, src := range cfg.Sources {
+		if src.Enabled {
+			return true
+		}
+	}
+	return false
+}
+
+func decodeCopyMode(r *http.Request, fallback config.OverwriteMode) (config.OverwriteMode, error) {
+	var req struct {
+		Mode string `json:"mode"`
+	}
+	if r.Body != nil {
+		if err := json.NewDecoder(r.Body).Decode(&req); err != nil && !errors.Is(err, io.EOF) {
+			return "", err
+		}
+	}
+	switch req.Mode {
+	case "", "add":
+		return config.OverwriteSkip, nil
+	case "replace":
+		return config.OverwriteDelete, nil
+	default:
+		return fallback, errors.New("invalid copy mode")
+	}
+}
+
 func (s *Server) handleCopyStart(w http.ResponseWriter, r *http.Request) {
 	diskID := r.PathValue("diskID")
 	diskInfo, ok := s.deps.Watcher.DiskByID(diskID)
@@ -21,26 +62,67 @@ func (s *Server) handleCopyStart(w http.ResponseWriter, r *http.Request) {
 	}
 
 	cfg := s.deps.Config
-	hasEnabledSources := false
+	if !hasEnabledSources(cfg) {
-	for _, src := range cfg.Sources {
+		jsonErr(w, http.StatusUnprocessableEntity, "no source folders selected")
-		if src.Enabled {
+		return
-			hasEnabledSources = true
-			break
-		}
 	}
-	if !hasEnabledSources {
+
+	overwriteMode, err := decodeCopyMode(r, cfg.OverwriteMode)
+	if err != nil {
+		if err.Error() == "invalid copy mode" {
+			jsonErr(w, http.StatusBadRequest, err.Error())
+			return
+		}
+		jsonErr(w, http.StatusBadRequest, "invalid JSON: "+err.Error())
+		return
+	}
+
+	reserveBytes := int64(cfg.ReserveFreeGB * 1e9)
+	if diskInfo.FreeBytes <= reserveBytes {
+		jsonErr(w, http.StatusUnprocessableEntity, "free space is below reserve threshold")
+		return
+	}
+
+	opts := s.copyOptions(cfg, diskInfo, overwriteMode)
+
+	taskID, err := s.deps.Copier.Start(context.Background(), opts)
+	if err != nil {
+		switch err.Error() {
+		case "copy already running":
+			jsonErr(w, http.StatusConflict, err.Error())
+		default:
+			jsonErr(w, http.StatusUnprocessableEntity, err.Error())
+		}
+		return
+	}
+
+	w.WriteHeader(http.StatusAccepted)
+	jsonOK(w, map[string]string{"task_id": taskID})
+}
+
+func (s *Server) handleCopyStartSelected(w http.ResponseWriter, r *http.Request) {
+	cfg := s.deps.Config
+	if !hasEnabledSources(cfg) {
 		jsonErr(w, http.StatusUnprocessableEntity, "no source folders selected")
 		return
 	}
 
 	var req struct {
-		Mode string `json:"mode"`
+		MountPath string `json:"mount_path"`
+		Mode      string `json:"mode"`
 	}
-	if r.Body != nil {
+	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		if err := json.NewDecoder(r.Body).Decode(&req); err != nil && !errors.Is(err, io.EOF) {
+		jsonErr(w, http.StatusBadRequest, "invalid JSON: "+err.Error())
-			jsonErr(w, http.StatusBadRequest, "invalid JSON: "+err.Error())
+		return
-			return
+	}
-		}
+	diskInfo, err := s.deps.ProbeDisk(req.MountPath)
+	if err != nil {
+		jsonErr(w, http.StatusBadRequest, err.Error())
+		return
+	}
+	if diskInfo.State != disk.DiskKnown {
+		jsonErr(w, http.StatusUnprocessableEntity, "selected directory is not an initialized jukebox disk")
+		return
 	}
 
 	overwriteMode := cfg.OverwriteMode
@@ -60,18 +142,10 @@ func (s *Server) handleCopyStart(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	opts := copier.Options{
+	if s.deps.OnDiskInit != nil {
-		DiskID:         diskInfo.DiskID,
+		s.deps.OnDiskInit(diskInfo.MountPath, diskInfo.DiskID)
-		MountPath:      diskInfo.MountPath,
-		MediaPath:      s.deps.MediaPath,
-		DestFolder:     cfg.DestFolder,
-		SourceRules:    cfg.Sources,
-		ReserveFreeGB:  cfg.ReserveFreeGB,
-		OverwriteMode:  overwriteMode,
-		FileSelectMode: cfg.FileSelectMode,
 	}
-
+	taskID, err := s.deps.Copier.Start(context.Background(), s.copyOptions(cfg, diskInfo, overwriteMode))
-	taskID, err := s.deps.Copier.Start(context.Background(), opts)
 	if err != nil {
 		switch err.Error() {
 		case "copy already running":

internal/api/handlers_disk.go

@@ -8,6 +8,28 @@ import (
 	"jukebox_maker/internal/disk"
 )
 
+func (s *Server) diskResponse(info disk.DiskInfo) map[string]any {
+	item := map[string]any{
+		"state":       info.State,
+		"disk_id":     info.DiskID,
+		"total_bytes": info.TotalBytes,
+		"free_bytes":  info.FreeBytes,
+		"mount_path":  info.MountPath,
+	}
+	if info.DiskID != "" {
+		if s.deps.OnDiskInit != nil {
+			s.deps.OnDiskInit(info.MountPath, info.DiskID)
+		}
+		if lastCopiedAt, ok, err := s.deps.Copier.LastCopiedAt(info.DiskID); err == nil && ok {
+			item["last_copied_at"] = lastCopiedAt.Format(time.RFC3339)
+		}
+		if t, ok := s.deps.Tasks.ActiveTaskByDisk(info.DiskID); ok {
+			item["active_task_id"] = t.ID
+		}
+	}
+	return item
+}
+
 func (s *Server) handleDiskStatus(w http.ResponseWriter, r *http.Request) {
 	type response struct {
 		State        disk.DiskState `json:"state"`
@@ -29,12 +51,12 @@ func (s *Server) handleDiskStatus(w http.ResponseWriter, r *http.Request) {
 			FreeBytes:  info.FreeBytes,
 			MountPath:  info.MountPath,
 		}
-		if info.DiskID != "" {
+		if payload := s.diskResponse(info); payload != nil {
-			if lastCopiedAt, ok, err := s.deps.Copier.LastCopiedAt(info.DiskID); err == nil && ok {
+			if v, ok := payload["last_copied_at"].(string); ok {
-				item.LastCopiedAt = lastCopiedAt.Format(time.RFC3339)
+				item.LastCopiedAt = v
 			}
-			if t, ok := s.deps.Tasks.ActiveTaskByDisk(info.DiskID); ok {
+			if v, ok := payload["active_task_id"].(string); ok {
-				item.ActiveTaskID = t.ID
+				item.ActiveTaskID = v
 			}
 		}
 		resp = append(resp, item)
@@ -43,6 +65,16 @@ func (s *Server) handleDiskStatus(w http.ResponseWriter, r *http.Request) {
 	jsonOK(w, map[string]any{"items": resp})
 }
 
+func (s *Server) handleDiskProbe(w http.ResponseWriter, r *http.Request) {
+	mountPath := r.URL.Query().Get("mount_path")
+	info, err := s.deps.ProbeDisk(mountPath)
+	if err != nil {
+		jsonErr(w, http.StatusBadRequest, err.Error())
+		return
+	}
+	jsonOK(w, s.diskResponse(info))
+}
+
 func (s *Server) handleDiskInit(w http.ResponseWriter, r *http.Request) {
 	var req struct {
 		MountPath string `json:"mount_path"`
@@ -52,9 +84,9 @@ func (s *Server) handleDiskInit(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	info, ok := s.deps.Watcher.DiskByMountPath(req.MountPath)
+	info, err := s.deps.ProbeDisk(req.MountPath)
-	if !ok {
+	if err != nil {
-		jsonErr(w, http.StatusNotFound, "disk not found")
+		jsonErr(w, http.StatusBadRequest, err.Error())
 		return
 	}
 	if info.State == disk.DiskAbsent {
@@ -76,7 +108,8 @@ func (s *Server) handleDiskInit(w http.ResponseWriter, r *http.Request) {
 		return
 	}
 
-	s.deps.OnDiskInit(info.MountPath, diskID)
+	if s.deps.OnDiskInit != nil {
-	s.deps.Watcher.ProbeNow()
+		s.deps.OnDiskInit(info.MountPath, diskID)
+	}
 	jsonOK(w, map[string]string{"disk_id": diskID})
 }

internal/api/handlers_sources.go

@@ -3,7 +3,6 @@ package api
 import (
 	"errors"
 	"net/http"
-	"net/url"
 	"os"
 	"path/filepath"
 	"sort"
@@ -11,20 +10,19 @@ import (
 )
 
 func (s *Server) handleSources(w http.ResponseWriter, r *http.Request) {
-	relPath, err := normalizeSourcePath(r.URL.Query().Get("path"))
+	absPath, err := normalizeSourcePathQuery(r.URL.Query().Get("path"))
 	if err != nil {
 		jsonErr(w, http.StatusBadRequest, err.Error())
 		return
 	}
-
+	if absPath == "" {
-	absPath := s.deps.MediaPath
+		jsonOK(w, map[string]any{"path": "", "items": []map[string]string{}})
-	if relPath != "" {
+		return
-		absPath = filepath.Join(absPath, relPath)
 	}
 
 	entries, err := os.ReadDir(absPath)
 	if err != nil {
-		jsonOK(w, map[string]any{"path": relPath, "items": []map[string]string{}})
+		jsonOK(w, map[string]any{"path": absPath, "items": []map[string]string{}})
 		return
 	}
 
@@ -38,13 +36,10 @@ func (s *Server) handleSources(w http.ResponseWriter, r *http.Request) {
 		if !e.IsDir() || strings.HasPrefix(e.Name(), ".") {
 			continue
 		}
-		childPath := e.Name()
+		childPath := filepath.Join(absPath, e.Name())
-		if relPath != "" {
-			childPath = filepath.Join(relPath, childPath)
-		}
 		items = append(items, item{
 			Name: e.Name(),
-			Path: filepath.ToSlash(childPath),
+			Path: childPath,
 		})
 	}
 
@@ -53,26 +48,18 @@ func (s *Server) handleSources(w http.ResponseWriter, r *http.Request) {
 	})
 
 	jsonOK(w, map[string]any{
-		"path":  relPath,
+		"path":  absPath,
 		"items": items,
 	})
 }
 
-func normalizeSourcePath(raw string) (string, error) {
+func normalizeSourcePathQuery(raw string) (string, error) {
-	raw, _ = url.QueryUnescape(raw)
 	raw = strings.TrimSpace(raw)
-	raw = filepath.ToSlash(raw)
-	raw = strings.TrimPrefix(raw, "/")
 	if raw == "" || raw == "." {
 		return "", nil
 	}
-
 	clean := filepath.Clean(raw)
-	clean = filepath.ToSlash(clean)
+	if !filepath.IsAbs(clean) {
-	if clean == "." {
-		return "", nil
-	}
-	if clean == ".." || strings.HasPrefix(clean, "../") {
 		return "", errors.New("invalid source path")
 	}
 	return clean, nil

internal/api/handlers_system.go

@@ -0,0 +1,16 @@
+package api
+
+import (
+	"net/http"
+
+	"jukebox_maker/internal/dialog"
+)
+
+func (s *Server) handlePickFolder(w http.ResponseWriter, r *http.Request) {
+	path, err := dialog.PickFolder()
+	if err != nil {
+		jsonErr(w, http.StatusUnprocessableEntity, err.Error())
+		return
+	}
+	jsonOK(w, map[string]string{"path": path})
+}

internal/api/server.go

@@ -9,6 +9,7 @@ import (
 
 	"jukebox_maker/internal/config"
 	"jukebox_maker/internal/copier"
+	"jukebox_maker/internal/disk"
 	"jukebox_maker/internal/task"
 	"jukebox_maker/internal/watcher"
 )
@@ -20,8 +21,7 @@ type Deps struct {
 	Watcher    *watcher.Watcher
 	Copier     *copier.Copier
 	Tasks      *task.Store
-	MediaPath  string
+	ProbeDisk  func(mountPath string) (disk.DiskInfo, error)
-	MountPath  string
 	// OnDiskInit вызывается при ручной инициализации диска через UI.
 	OnDiskInit func(mountPath, diskID string)
 }
@@ -60,10 +60,13 @@ func (s *Server) routes() {
 
 	s.mux.HandleFunc("GET /health", s.handleHealth)
 	s.mux.HandleFunc("GET /api/disks", s.handleDiskStatus)
+	s.mux.HandleFunc("GET /api/disks/probe", s.handleDiskProbe)
 	s.mux.HandleFunc("POST /api/disks/init", s.handleDiskInit)
+	s.mux.HandleFunc("POST /api/disks/copy/start", s.handleCopyStartSelected)
 	s.mux.HandleFunc("GET /api/sources", s.handleSources)
 	s.mux.HandleFunc("GET /api/config", s.handleGetConfig)
 	s.mux.HandleFunc("PUT /api/config", s.handlePutConfig)
+	s.mux.HandleFunc("POST /api/system/pick-folder", s.handlePickFolder)
 	s.mux.HandleFunc("POST /api/disks/{diskID}/copy/start", s.handleCopyStart)
 	s.mux.HandleFunc("POST /api/disks/{diskID}/copy/cancel", s.handleCopyCancel)
 	s.mux.HandleFunc("GET /api/tasks/{id}", s.handleTaskGet)

internal/config/config.go

@@ -26,15 +26,17 @@ const (
 type SourceFolder struct {
 	Path    string `json:"path"`
 	Enabled bool   `json:"enabled"`
+	Root    bool   `json:"root,omitempty"`
 }
 
 type Config struct {
-	ReserveFreeGB  float64        `json:"reserve_free_gb"`
+	MediaPath         string              `json:"media_path"`
-	DestFolder     string         `json:"dest_folder"`
+	ReserveFreeGB     float64             `json:"reserve_free_gb"`
-	Sources        []SourceFolder `json:"sources"`
+	DestFolder        string              `json:"dest_folder"`
-	OverwriteMode  OverwriteMode  `json:"overwrite_mode"`
+	Sources           []SourceFolder      `json:"sources"`
-	FileSelectMode FileSelectMode `json:"file_select_mode"`
+	OverwriteMode     OverwriteMode       `json:"overwrite_mode"`
-	AutoCopy       bool           `json:"auto_copy"`
+	FileSelectMode    FileSelectMode      `json:"file_select_mode"`
+	AutoCopy          bool                `json:"auto_copy"`
 	FileReplicaCounts map[string]int      `json:"file_replica_counts,omitempty"`
 	DiskReplicaFiles  map[string][]string `json:"disk_replica_files,omitempty"`
 }
@@ -67,6 +69,8 @@ func Load(path string) (*Config, error) {
 	} else {
 		cfg.DestFolder = defaults().DestFolder
 	}
+	cfg.MediaPath = NormalizeMediaPath(cfg.MediaPath)
+	cfg.Sources = NormalizeSources(cfg.Sources, cfg.MediaPath)
 	return &cfg, nil
 }
 
@@ -86,6 +90,26 @@ func Save(path string, cfg *Config) error {
 }
 
 func (c *Config) Validate() error {
+	c.MediaPath = NormalizeMediaPath(c.MediaPath)
+	if c.MediaPath != "" {
+		info, err := os.Stat(c.MediaPath)
+		if err != nil {
+			return errors.New("media_path is not accessible")
+		}
+		if !info.IsDir() {
+			return errors.New("media_path must be a directory")
+		}
+	}
+	c.Sources = NormalizeSources(c.Sources, c.MediaPath)
+	for _, source := range c.Sources {
+		info, err := os.Stat(source.Path)
+		if err != nil {
+			return errors.New("source path is not accessible: " + source.Path)
+		}
+		if !info.IsDir() {
+			return errors.New("source path must be a directory: " + source.Path)
+		}
+	}
 	if c.ReserveFreeGB < 0 {
 		return errors.New("reserve_free_gb must be >= 0")
 	}
@@ -105,6 +129,46 @@ func (c *Config) Validate() error {
 	return nil
 }
 
+func NormalizeMediaPath(value string) string {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return ""
+	}
+	return filepath.Clean(value)
+}
+
+func NormalizeSources(items []SourceFolder, mediaPath string) []SourceFolder {
+	seen := make(map[string]struct{}, len(items))
+	result := make([]SourceFolder, 0, len(items))
+	for _, item := range items {
+		path := normalizeSourcePath(item.Path, mediaPath)
+		if path == "" {
+			continue
+		}
+		if _, ok := seen[path]; ok {
+			continue
+		}
+		seen[path] = struct{}{}
+		result = append(result, SourceFolder{
+			Path:    path,
+			Enabled: item.Enabled,
+			Root:    item.Root,
+		})
+	}
+	return result
+}
+
+func normalizeSourcePath(value string, mediaPath string) string {
+	value = strings.TrimSpace(value)
+	if value == "" {
+		return ""
+	}
+	if !filepath.IsAbs(value) && mediaPath != "" {
+		value = filepath.Join(mediaPath, value)
+	}
+	return filepath.Clean(value)
+}
+
 func NormalizeDestFolder(value string) (string, error) {
 	value = strings.TrimSpace(value)
 	if value == "" {

internal/copier/copier.go

@@ -5,9 +5,10 @@ import (
 	"encoding/json"
 	"errors"
 	"fmt"
+	"hash/fnv"
+	"io"
 	"math/rand/v2"
 	"os"
-	"os/exec"
 	"path/filepath"
 	"sort"
 	"strings"
@@ -322,7 +323,7 @@ func (c *Copier) run(ctx context.Context, taskID string, opts Options, database
 		}
 
 		dstAbs := filepath.Join(destRoot, f.relPath)
-		if err := rsyncFile(ctx, f.srcAbs, dstAbs); err != nil {
+		if err := copyFile(ctx, f.srcAbs, dstAbs); err != nil {
 			if errors.Is(err, context.Canceled) {
 				c.tasks.Update(taskID, func(t *task.Task) {
 					t.Status = task.StatusCanceled
@@ -358,11 +359,24 @@ type fileEntry struct {
 }
 
 func buildFileList(mediaPath string, rules []config.SourceFolder, skip map[string]struct{}) ([]fileEntry, error) {
-	roots, ruleMap := normalizeSourceRules(rules)
+	_ = mediaPath
+	roots, selectedRoots, ruleMap := normalizeSourceRules(rules)
+	aliases := sourceAliases(roots)
 
 	var result []fileEntry
-	for _, src := range roots {
+	for _, src := range selectedRoots {
-		dir := filepath.Join(mediaPath, src)
+		root := owningRoot(src, roots)
+		if root == "" {
+			root = src
+		}
+		alias := aliases[root]
+		if alias == "" {
+			alias = filepath.Base(root)
+			if alias == "." || alias == "" || alias == string(filepath.Separator) {
+				alias = "source-" + shortHash(root)
+			}
+		}
+		dir := src
 		err := filepath.WalkDir(dir, func(path string, d os.DirEntry, err error) error {
 			if err != nil || d.IsDir() {
 				if err != nil {
@@ -371,29 +385,33 @@ func buildFileList(mediaPath string, rules []config.SourceFolder, skip map[strin
 				if path == dir {
 					return nil
 				}
-				rel, relErr := filepath.Rel(mediaPath, path)
+				rel, relErr := filepath.Rel(root, path)
 				if relErr != nil {
 					return nil
 				}
 				rel = filepath.ToSlash(rel)
-				if !isPathEnabled(rel, ruleMap) && !hasEnabledDescendant(rel, ruleMap) {
+				if !isPathEnabled(path, ruleMap) && !hasEnabledDescendant(path, ruleMap) {
 					return filepath.SkipDir
 				}
 				return nil
 			}
-			rel, _ := filepath.Rel(mediaPath, path)
+			if !isPathEnabled(path, ruleMap) {
-			rel = filepath.ToSlash(rel)
-			if !isPathEnabled(rel, ruleMap) {
 				return nil
 			}
+			rel, _ := filepath.Rel(root, path)
+			rel = filepath.ToSlash(rel)
+			destRel := filepath.ToSlash(filepath.Join(alias, rel))
 			if _, skipped := skip[rel]; skipped {
 				return nil
 			}
+			if _, skipped := skip[destRel]; skipped {
+				return nil
+			}
 			info, err := d.Info()
 			if err != nil {
 				return nil
 			}
-			result = append(result, fileEntry{srcAbs: path, relPath: rel, size: info.Size()})
+			result = append(result, fileEntry{srcAbs: path, relPath: destRel, size: info.Size()})
 			return nil
 		})
 		if err != nil {
@@ -403,30 +421,35 @@ func buildFileList(mediaPath string, rules []config.SourceFolder, skip map[strin
 	return result, nil
 }
 
-func normalizeSourceRules(rules []config.SourceFolder) ([]string, map[string]bool) {
+func normalizeSourceRules(rules []config.SourceFolder) ([]string, []string, map[string]bool) {
 	ruleMap := make(map[string]bool, len(rules))
+	rootSet := make(map[string]struct{})
 	for _, rule := range rules {
-		src := filepath.ToSlash(filepath.Clean(strings.TrimSpace(rule.Path)))
+		src := filepath.Clean(strings.TrimSpace(rule.Path))
-		src = strings.TrimPrefix(src, "./")
-		src = strings.TrimPrefix(src, "/")
 		if src == "" || src == "." {
 			continue
 		}
-		if src == ".." || strings.HasPrefix(src, "../") {
-			continue
-		}
 		ruleMap[src] = rule.Enabled
+		if rule.Root {
+			rootSet[src] = struct{}{}
+		}
 	}
 
 	var roots []string
+	for src := range rootSet {
+		roots = append(roots, src)
+	}
+	sort.Strings(roots)
+
+	var selectedRoots []string
 	for src, enabled := range ruleMap {
 		if !enabled || hasEnabledAncestor(src, ruleMap) {
 			continue
 		}
-		roots = append(roots, src)
+		selectedRoots = append(selectedRoots, src)
 	}
-	sort.Strings(roots)
+	sort.Strings(selectedRoots)
-	return roots, ruleMap
+	return roots, selectedRoots, ruleMap
 }
 
 func hasEnabledAncestor(path string, ruleMap map[string]bool) bool {
@@ -439,9 +462,8 @@ func hasEnabledAncestor(path string, ruleMap map[string]bool) bool {
 }
 
 func hasEnabledDescendant(path string, ruleMap map[string]bool) bool {
-	prefix := path + "/"
 	for other, enabled := range ruleMap {
-		if enabled && strings.HasPrefix(other, prefix) {
+		if enabled && isPathInside(path, other) && other != path {
 			return true
 		}
 	}
@@ -458,36 +480,153 @@ func isPathEnabled(path string, ruleMap map[string]bool) bool {
 }
 
 func parentSourcePath(path string) string {
-	idx := strings.LastIndex(path, "/")
+	parent := filepath.Dir(path)
-	if idx < 0 {
+	if parent == "." || parent == path {
 		return ""
 	}
-	return path[:idx]
+	return parent
 }
 
-// rsyncFile copies src to dst using rsync with resume support.
+func owningRoot(path string, roots []string) string {
-// --partial keeps partial files on interruption.
+	var best string
-// --append-verify resumes partial transfers and verifies checksums.
+	for _, root := range roots {
-func rsyncFile(ctx context.Context, src, dst string) error {
+		if isPathInside(root, path) {
+			if len(root) > len(best) {
+				best = root
+			}
+		}
+	}
+	return best
+}
+
+func sourceAliases(roots []string) map[string]string {
+	counts := make(map[string]int, len(roots))
+	for _, root := range roots {
+		counts[strings.ToLower(filepath.Base(root))]++
+	}
+
+	aliases := make(map[string]string, len(roots))
+	for _, root := range roots {
+		base := filepath.Base(root)
+		if base == "." || base == string(filepath.Separator) || base == "" {
+			base = "source"
+		}
+		key := strings.ToLower(base)
+		if counts[key] > 1 {
+			base = fmt.Sprintf("%s-%s", base, shortHash(root))
+		}
+		aliases[root] = base
+	}
+	return aliases
+}
+
+func shortHash(value string) string {
+	h := fnv.New32a()
+	_, _ = h.Write([]byte(value))
+	return fmt.Sprintf("%08x", h.Sum32())[:6]
+}
+
+func isPathInside(base, candidate string) bool {
+	if candidate == base {
+		return true
+	}
+	rel, err := filepath.Rel(base, candidate)
+	if err != nil {
+		return false
+	}
+	return rel != "." && rel != ".." && !strings.HasPrefix(rel, ".."+string(os.PathSeparator))
+}
+
+func copyFile(ctx context.Context, src, dst string) error {
 	if err := os.MkdirAll(filepath.Dir(dst), 0o755); err != nil {
 		return err
 	}
-	cmd := exec.CommandContext(ctx, "rsync",
+
-		"--partial",
+	srcFile, err := os.Open(src)
-		"--append-verify",
-		"--times",
-		"--no-perms",
-		"--no-owner",
-		"--no-group",
-		"--chmod=ugo=rwx",
-		src, dst,
-	)
-	out, err := cmd.CombinedOutput()
 	if err != nil {
-		if ctx.Err() != nil {
+		return err
-			return ctx.Err()
+	}
+	defer srcFile.Close()
+
+	srcInfo, err := srcFile.Stat()
+	if err != nil {
+		return err
+	}
+
+	offset := int64(0)
+	if dstInfo, err := os.Stat(dst); err == nil {
+		switch {
+		case dstInfo.Size() < srcInfo.Size():
+			offset = dstInfo.Size()
+		case dstInfo.Size() == srcInfo.Size():
+			return os.Chtimes(dst, srcInfo.ModTime(), srcInfo.ModTime())
+		default:
+			if err := os.Remove(dst); err != nil {
+				return err
+			}
 		}
-		return fmt.Errorf("rsync: %w: %s", err, out)
+	} else if !errors.Is(err, os.ErrNotExist) {
+		return err
+	}
+
+	if offset > 0 {
+		if _, err := srcFile.Seek(offset, io.SeekStart); err != nil {
+			return err
+		}
+	}
+
+	dstFile, err := os.OpenFile(dst, os.O_CREATE|os.O_WRONLY, 0o644)
+	if err != nil {
+		return err
+	}
+	defer dstFile.Close()
+
+	if offset > 0 {
+		if _, err := dstFile.Seek(offset, io.SeekStart); err != nil {
+			return err
+		}
+	} else if err := dstFile.Truncate(0); err != nil {
+		return err
+	}
+
+	buf := make([]byte, 1024*1024)
+	for {
+		if err := ctx.Err(); err != nil {
+			return err
+		}
+
+		nr, readErr := srcFile.Read(buf)
+		if nr > 0 {
+			nw, writeErr := dstFile.Write(buf[:nr])
+			if writeErr != nil {
+				return writeErr
+			}
+			if nw != nr {
+				return io.ErrShortWrite
+			}
+		}
+
+		if readErr != nil {
+			if errors.Is(readErr, io.EOF) {
+				break
+			}
+			return readErr
+		}
+	}
+
+	if err := dstFile.Sync(); err != nil {
+		return err
+	}
+	if err := os.Chtimes(dst, srcInfo.ModTime(), srcInfo.ModTime()); err != nil {
+		return err
+	}
+
+	dstInfo, err := os.Stat(dst)
+	if err != nil {
+		return err
+	}
+	if dstInfo.Size() != srcInfo.Size() {
+		return fmt.Errorf("copied size mismatch for %s", filepath.Base(src))
 	}
 	return nil
 }

internal/dialog/pickfolder_darwin.go

@@ -0,0 +1,20 @@
+package dialog
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+)
+
+func PickFolder() (string, error) {
+	cmd := exec.Command("osascript", "-e", `POSIX path of (choose folder with prompt "Select a folder")`)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return "", fmt.Errorf("folder selection failed: %s", strings.TrimSpace(string(out)))
+	}
+	path := strings.TrimSpace(string(out))
+	if path == "" {
+		return "", fmt.Errorf("folder selection canceled")
+	}
+	return strings.TrimSuffix(path, "/"), nil
+}

internal/dialog/pickfolder_other.go

@@ -0,0 +1,9 @@
+//go:build !darwin && !windows
+
+package dialog
+
+import "fmt"
+
+func PickFolder() (string, error) {
+	return "", fmt.Errorf("native folder picker is not supported on this platform")
+}

internal/dialog/pickfolder_windows.go

@@ -0,0 +1,21 @@
+package dialog
+
+import (
+	"fmt"
+	"os/exec"
+	"strings"
+)
+
+func PickFolder() (string, error) {
+	script := `Add-Type -AssemblyName System.Windows.Forms; $dialog = New-Object System.Windows.Forms.FolderBrowserDialog; $dialog.ShowNewFolderButton = $false; if ($dialog.ShowDialog() -eq [System.Windows.Forms.DialogResult]::OK) { [Console]::Write($dialog.SelectedPath) }`
+	cmd := exec.Command("powershell", "-NoProfile", "-STA", "-Command", script)
+	out, err := cmd.CombinedOutput()
+	if err != nil {
+		return "", fmt.Errorf("folder selection failed: %s", strings.TrimSpace(string(out)))
+	}
+	path := strings.TrimSpace(string(out))
+	if path == "" {
+		return "", fmt.Errorf("folder selection canceled")
+	}
+	return path, nil
+}

internal/disk/disk.go

@@ -5,7 +5,6 @@ import (
 	"os"
 	"path/filepath"
 	"strings"
-	"syscall"
 
 	"github.com/google/uuid"
 )
@@ -59,30 +58,6 @@ func Probe(mountPath string) (DiskInfo, error) {
 	return info, nil
 }
 
-func IsMountPoint(path string) bool {
-	pathInfo, err := os.Stat(path)
-	if err != nil {
-		return false
-	}
-
-	parent := filepath.Dir(filepath.Clean(path))
-	parentInfo, err := os.Stat(parent)
-	if err != nil {
-		return false
-	}
-
-	pathStat, ok := pathInfo.Sys().(*syscall.Stat_t)
-	if !ok {
-		return false
-	}
-	parentStat, ok := parentInfo.Sys().(*syscall.Stat_t)
-	if !ok {
-		return false
-	}
-
-	return pathStat.Dev != parentStat.Dev
-}
-
 func CheckWritable(path string) error {
 	f, err := os.CreateTemp(path, ".jukebox-writecheck-*")
 	if err != nil {
@@ -112,13 +87,3 @@ func InitDisk(mountPath string) (string, error) {
 func DBPath(mountPath string) string {
 	return filepath.Join(mountPath, MarkerDir, "history.db")
 }
-
-func DiskUsage(mountPath string) (total, free int64, err error) {
-	var stat syscall.Statfs_t
-	if err = syscall.Statfs(mountPath, &stat); err != nil {
-		return 0, 0, err
-	}
-	total = int64(stat.Blocks) * int64(stat.Bsize)
-	free = int64(stat.Bavail) * int64(stat.Bsize)
-	return total, free, nil
-}

internal/disk/storage_unix.go

@@ -0,0 +1,43 @@
+//go:build !windows
+
+package disk
+
+import (
+	"os"
+	"path/filepath"
+	"syscall"
+)
+
+func IsMountPoint(path string) bool {
+	pathInfo, err := os.Stat(path)
+	if err != nil {
+		return false
+	}
+
+	parent := filepath.Dir(filepath.Clean(path))
+	parentInfo, err := os.Stat(parent)
+	if err != nil {
+		return false
+	}
+
+	pathStat, ok := pathInfo.Sys().(*syscall.Stat_t)
+	if !ok {
+		return false
+	}
+	parentStat, ok := parentInfo.Sys().(*syscall.Stat_t)
+	if !ok {
+		return false
+	}
+
+	return pathStat.Dev != parentStat.Dev
+}
+
+func DiskUsage(mountPath string) (total, free int64, err error) {
+	var stat syscall.Statfs_t
+	if err = syscall.Statfs(mountPath, &stat); err != nil {
+		return 0, 0, err
+	}
+	total = int64(stat.Blocks) * int64(stat.Bsize)
+	free = int64(stat.Bavail) * int64(stat.Bsize)
+	return total, free, nil
+}

internal/disk/storage_windows.go

@@ -0,0 +1,40 @@
+//go:build windows
+
+package disk
+
+import (
+	"path/filepath"
+	"strings"
+
+	"golang.org/x/sys/windows"
+)
+
+func IsMountPoint(path string) bool {
+	clean := filepath.Clean(path)
+	volume := filepath.VolumeName(clean)
+	if volume == "" {
+		return false
+	}
+	root := volume + `\`
+	return strings.EqualFold(clean, root)
+}
+
+func DiskUsage(mountPath string) (total, free int64, err error) {
+	root := filepath.Clean(mountPath)
+	if volume := filepath.VolumeName(root); volume != "" {
+		root = volume + `\`
+	}
+
+	pathPtr, err := windows.UTF16PtrFromString(root)
+	if err != nil {
+		return 0, 0, err
+	}
+
+	var freeBytesAvailable uint64
+	var totalNumberOfBytes uint64
+	var totalNumberOfFreeBytes uint64
+	if err := windows.GetDiskFreeSpaceEx(pathPtr, &freeBytesAvailable, &totalNumberOfBytes, &totalNumberOfFreeBytes); err != nil {
+		return 0, 0, err
+	}
+	return int64(totalNumberOfBytes), int64(freeBytesAvailable), nil
+}

ops/build-release.sh

@@ -0,0 +1,39 @@
+#!/bin/sh
+
+set -eu
+
+ROOT_DIR=$(CDPATH= cd -- "$(dirname "$0")/.." && pwd)
+RELEASE_DIR="${ROOT_DIR}/release"
+CACHE_DIR="${RELEASE_DIR}/.gocache"
+VERSION=${VERSION:-$(git -C "${ROOT_DIR}" describe --tags --always 2>/dev/null || echo dev)}
+
+build_target() {
+    goos="$1"
+    goarch="$2"
+    output_name="$3"
+
+    echo "building ${goos}/${goarch} -> ${output_name}"
+    env \
+        GOCACHE="${CACHE_DIR}" \
+        GOOS="${goos}" \
+        GOARCH="${goarch}" \
+        go build \
+        -ldflags "-X main.Version=${VERSION}" \
+        -o "${RELEASE_DIR}/${output_name}" \
+        ./cmd/jukebox
+}
+
+command -v go >/dev/null 2>&1 || {
+    echo "error: go not found in PATH" >&2
+    exit 1
+}
+
+mkdir -p "${RELEASE_DIR}" "${CACHE_DIR}"
+
+build_target darwin arm64 jukebox-darwin-arm64
+build_target windows 386 jukebox-windows-386.exe
+
+echo ""
+echo "artifacts:"
+echo "  ${RELEASE_DIR}/jukebox-darwin-arm64"
+echo "  ${RELEASE_DIR}/jukebox-windows-386.exe"

web/static/style.css

@@ -225,6 +225,17 @@ a:hover { text-decoration: underline; }
 
 .form-group { display: flex; flex-direction: column; gap: 5px; }
 
+.path-input-row {
+  display: flex;
+  gap: 8px;
+  align-items: center;
+}
+
+.path-input-row .form-input {
+  flex: 1;
+  min-width: 0;
+}
+
 .form-label {
   font-size: 13px;
   font-weight: 700;
@@ -268,10 +279,25 @@ a:hover { text-decoration: underline; }
 /* Checkbox list */
 .source-list { display: flex; flex-direction: column; gap: 0; }
 .source-tree {
-  padding: 8px 0;
+  padding: 12px;
+  background: linear-gradient(180deg, rgba(33, 133, 208, 0.03), rgba(34, 36, 38, 0.015));
 }
 .source-tree-empty {
-  padding: 12px 16px;
+  padding: 20px 16px;
+  border: 1px dashed var(--border);
+  border-radius: calc(var(--radius) + 2px);
+  background: rgba(255, 255, 255, 0.75);
+}
+.source-root-card {
+  margin-bottom: 12px;
+  overflow: hidden;
+  border: 1px solid rgba(33, 133, 208, 0.18);
+  border-radius: calc(var(--radius) + 2px);
+  background: rgba(255, 255, 255, 0.92);
+  box-shadow: 0 8px 24px rgba(27, 28, 29, 0.04);
+}
+.source-root-card:last-child {
+  margin-bottom: 0;
 }
 .source-node {
   border-bottom: 1px solid var(--border-lite);
@@ -284,10 +310,22 @@ a:hover { text-decoration: underline; }
   align-items: center;
   gap: 8px;
   padding: 8px 16px;
+  transition: background 0.12s ease;
 }
 .source-row:hover {
   background: rgba(33, 133, 208, 0.04);
 }
+.source-root-row {
+  padding-top: 12px;
+  padding-bottom: 12px;
+  border-bottom: 1px solid rgba(33, 133, 208, 0.12);
+  background:
+    linear-gradient(90deg, rgba(33, 133, 208, 0.08), rgba(33, 133, 208, 0.015) 42%, rgba(255, 255, 255, 0.96) 100%);
+}
+.source-root-row:hover {
+  background:
+    linear-gradient(90deg, rgba(33, 133, 208, 0.12), rgba(33, 133, 208, 0.03) 42%, rgba(255, 255, 255, 1) 100%);
+}
 .source-toggle {
   width: 24px;
   height: 24px;
@@ -318,12 +356,40 @@ a:hover { text-decoration: underline; }
   min-width: 0;
   flex: 1;
 }
+.source-root-title {
+  display: flex;
+  align-items: center;
+  gap: 8px;
+  min-width: 0;
+}
+.source-root-badge {
+  display: inline-flex;
+  align-items: center;
+  padding: 2px 7px;
+  border-radius: 999px;
+  background: rgba(33, 133, 208, 0.1);
+  color: var(--accent-dark);
+  font-size: 11px;
+  font-weight: 700;
+  letter-spacing: 0.02em;
+  text-transform: uppercase;
+}
 .source-item-hint {
   font-size: 12px;
   color: var(--muted);
 }
 .source-children {
-  padding-left: 20px;
+  position: relative;
+  padding: 6px 0 8px 0;
+}
+.source-children::before {
+  content: "";
+  position: absolute;
+  left: 26px;
+  top: 0;
+  bottom: 8px;
+  width: 1px;
+  background: linear-gradient(180deg, rgba(33, 133, 208, 0.2), rgba(33, 133, 208, 0.03));
 }
 .source-loading {
   padding: 6px 16px 10px 48px;
@@ -418,4 +484,11 @@ a:hover { text-decoration: underline; }
   .disk-grid { grid-template-columns: 1fr; }
   .kv-table th { width: 130px; }
   .btn-row { flex-wrap: wrap; }
+  .path-input-row { flex-wrap: wrap; }
+  .source-root-row {
+    align-items: flex-start;
+  }
+  .source-root-title {
+    flex-wrap: wrap;
+  }
 }

web/templates/dashboard.html

@@ -1,16 +1,21 @@
 {{define "content"}}
 
 <section class="panel">
-  <h2>Disks</h2>
+  <h2>Mounted Disk</h2>
   <div class="panel-body">
-    <div id="diskSummary" class="text-muted">Loading disks...</div>
+    <div class="path-input-row">
+      <input class="form-input" type="text" id="mountPath" placeholder="/Volumes/JUKEBOX or E:\\">
+      <button type="button" class="button-primary" onclick="pickMountPath()">+</button>
+      <button type="button" class="button-secondary" onclick="refreshSelectedDisk()">Refresh</button>
+    </div>
+    <div class="form-hint">Choose the directory where the removable disk is mounted. The app works with one selected disk at a time in standalone mode.</div>
   </div>
 </section>
 
-<div class="disk-grid" id="diskGrid"></div>
+<div id="diskState"></div>
 
 <script>
-let disks = [];
+const selectedDisk = { info: null };
 const taskState = new Map();
 const taskPollers = new Map();
 
@@ -24,16 +29,12 @@ function escapeHTML(value) {
   }[char]));
 }
 
-function diskKey(disk) {
-  return disk.disk_id || disk.mount_path;
-}
-
 function badgeClass(state) {
   return ({ absent: 'badge-unknown', foreign: 'badge-warn', known: 'badge-ok' })[state] || 'badge-unknown';
 }
 
 function badgeLabel(state) {
-  return ({ absent: 'Not connected', foreign: 'Uninitialized disk', known: 'Ready' })[state] || '—';
+  return ({ absent: 'Directory unavailable', foreign: 'Uninitialized disk', known: 'Ready' })[state] || '—';
 }
 
 function fmtSpeed(bps) {
@@ -69,77 +70,74 @@ function taskMeta(task) {
   return [fmtSpeed(task.speed_bps), task.eta_sec ? 'ETA: ' + fmtETA(task.eta_sec) : ''].filter(Boolean).join(' · ');
 }
 
-function renderDisks() {
+function renderDisk() {
-  const grid = document.getElementById('diskGrid');
+  const root = document.getElementById('diskState');
-  const summary = document.getElementById('diskSummary');
+  const disk = selectedDisk.info;
-
+  if (!disk) {
-  if (!disks.length) {
+    root.innerHTML = `
-    summary.textContent = 'No disks found.';
+      <section class="panel">
-    grid.innerHTML = '';
+        <div class="panel-body text-muted">Choose a mounted disk directory to inspect it.</div>
+      </section>
+    `;
     return;
   }
 
-  const knownCount = disks.filter((disk) => disk.state === 'known').length;
+  const activeTask = disk.active_task_id ? taskState.get(disk.active_task_id) : null;
-  summary.textContent = `Disks found: ${disks.length}. Ready to copy: ${knownCount}.`;
+  const progress = activeTask ? activeTask.progress : 0;
+  const message = activeTask ? (activeTask.message || 'Preparing...') : '';
+  const meta = activeTask ? taskMeta(activeTask) : '';
+  const isKnown = disk.state === 'known';
+  const isForeign = disk.state === 'foreign';
+  const hasCapacity = disk.state !== 'absent';
 
-  grid.innerHTML = disks.map((disk) => {
+  root.innerHTML = `
-    const activeTask = disk.active_task_id ? taskState.get(disk.active_task_id) : null;
+    <section class="panel disk-card">
-    const progress = activeTask ? activeTask.progress : 0;
+      <h2>${escapeHTML(disk.mount_path)}</h2>
-    const message = activeTask ? (activeTask.message || 'Preparing...') : '';
+      <table class="kv-table">
-    const meta = activeTask ? taskMeta(activeTask) : '';
+        <tbody>
-    const isKnown = disk.state === 'known';
+          <tr>
-    const isForeign = disk.state === 'foreign';
+            <th>Status</th>
-    const hasCapacity = disk.state !== 'absent';
+            <td><span class="badge ${badgeClass(disk.state)}">${badgeLabel(disk.state)}</span></td>
-
+          </tr>
-    return `
+          <tr>
-      <section class="panel disk-card">
+            <th>Disk ID</th>
-        <h2>${escapeHTML(disk.mount_path)}</h2>
+            <td>${disk.disk_id ? `<span class="mono">${escapeHTML(disk.disk_id)}</span>` : '<span class="text-muted">not initialized yet</span>'}</td>
-        <table class="kv-table">
+          </tr>
-          <tbody>
+          <tr>
-            <tr>
+            <th>Total capacity</th>
-              <th>Status</th>
+            <td>${hasCapacity ? fmtBytes(disk.total_bytes) : '—'}</td>
-              <td><span class="badge ${badgeClass(disk.state)}">${badgeLabel(disk.state)}</span></td>
+          </tr>
-            </tr>
+          <tr>
-            <tr>
+            <th>Free space</th>
-              <th>Disk ID</th>
+            <td>${hasCapacity ? fmtBytes(disk.free_bytes) : '—'}</td>
-              <td>${disk.disk_id ? `<span class="mono">${escapeHTML(disk.disk_id)}</span>` : '<span class="text-muted">not initialized yet</span>'}</td>
+          </tr>
-            </tr>
+          <tr>
-            <tr>
+            <th>Last copied</th>
-              <th>Total capacity</th>
+            <td>${fmtDateTime(disk.last_copied_at)}</td>
-              <td>${hasCapacity ? fmtBytes(disk.total_bytes) : '—'}</td>
+          </tr>
-            </tr>
+        </tbody>
-            <tr>
+      </table>
-              <th>Free space</th>
+      ${activeTask ? `
-              <td>${hasCapacity ? fmtBytes(disk.free_bytes) : '—'}</td>
+        <div class="panel-body progress-wrap">
-            </tr>
+          <div class="progress-bar-bg">
-            <tr>
+            <div class="progress-bar-fill" style="width:${progress}%"></div>
-              <th>Last copied</th>
-              <td>${fmtDateTime(disk.last_copied_at)}</td>
-            </tr>
-          </tbody>
-        </table>
-        ${activeTask ? `
-          <div class="panel-body progress-wrap">
-            <div class="progress-bar-bg">
-              <div class="progress-bar-fill" style="width:${progress}%"></div>
-            </div>
-            <div class="progress-label">${escapeHTML(message)}</div>
-            <div class="progress-label">${escapeHTML(meta)}</div>
           </div>
-        ` : ''}
+          <div class="progress-label">${escapeHTML(message)}</div>
-        <div class="btn-row">
+          <div class="progress-label">${escapeHTML(meta)}</div>
-          ${isKnown ? `
-            <button class="button-danger" data-action="start-copy" data-mode="replace" data-disk-id="${escapeHTML(disk.disk_id)}" ${activeTask ? 'disabled' : ''}>Replace media</button>
-            <button class="button-primary" data-action="start-copy" data-mode="add" data-disk-id="${escapeHTML(disk.disk_id)}" ${activeTask ? 'disabled' : ''}>Add media</button>
-            <button class="button-danger ${activeTask ? '' : 'hidden'}" data-action="cancel-copy" data-disk-id="${escapeHTML(disk.disk_id)}">Cancel</button>
-          ` : ''}
-          ${isForeign ? `
-            <button class="button-secondary" data-action="init-disk" data-mount-path="${escapeHTML(disk.mount_path)}">Initialize disk</button>
-          ` : ''}
         </div>
-      </section>
+      ` : ''}
-    `;
+      <div class="btn-row">
-  }).join('');
+        ${isKnown ? `
+          <button class="button-danger" data-action="start-copy" data-mode="replace" ${activeTask ? 'disabled' : ''}>Replace media</button>
+          <button class="button-primary" data-action="start-copy" data-mode="add" ${activeTask ? 'disabled' : ''}>Add media</button>
+          <button class="button-danger ${activeTask ? '' : 'hidden'}" data-action="cancel-copy">Cancel</button>
+        ` : ''}
+        ${isForeign ? `
+          <button class="button-secondary" data-action="init-disk">Initialize disk</button>
+        ` : ''}
+      </div>
+    </section>
+  `;
 }
 
 function stopTaskPoll(taskID) {
@@ -154,28 +152,63 @@ function startTaskPoll(taskID) {
   pollTask(taskID);
 }
 
-async function refreshDisks() {
+async function pickFolder() {
-  try {
+  const response = await fetch('/api/system/pick-folder', { method: 'POST' });
-    const response = await fetch('/api/disks');
+  const payload = await response.json();
-    if (!response.ok) return;
+  if (!response.ok) {
-    const payload = await response.json();
+    throw new Error(payload.error || 'Failed to choose folder');
-    disks = payload.items || [];
+  }
-    renderDisks();
+  return payload.path || '';
+}
 
-    const activeTasks = new Set();
+async function pickMountPath() {
-    for (const disk of disks) {
+  try {
-      if (disk.active_task_id) {
+    const path = await pickFolder();
-        activeTasks.add(disk.active_task_id);
+    if (!path) return;
-        startTaskPoll(disk.active_task_id);
+    document.getElementById('mountPath').value = path;
-      }
+    localStorage.setItem('jukebox.selectedMountPath', path);
+    await refreshSelectedDisk();
+  } catch (error) {
+    toast(error.message || 'Failed to choose folder', 'error');
+  }
+}
+
+async function refreshSelectedDisk() {
+  const mountPath = document.getElementById('mountPath').value.trim();
+  if (!mountPath) {
+    selectedDisk.info = null;
+    renderDisk();
+    return;
+  }
+
+  localStorage.setItem('jukebox.selectedMountPath', mountPath);
+  try {
+    const response = await fetch('/api/disks/probe?mount_path=' + encodeURIComponent(mountPath));
+    const payload = await response.json();
+    if (!response.ok) {
+      toast(payload.error || 'Failed to inspect directory', 'error');
+      return;
     }
-    for (const taskID of Array.from(taskPollers.keys())) {
+    selectedDisk.info = payload;
-      if (!activeTasks.has(taskID)) {
+    renderDisk();
+
+    if (payload.active_task_id) {
+      for (const taskID of Array.from(taskPollers.keys())) {
+        if (taskID !== payload.active_task_id) {
+          stopTaskPoll(taskID);
+          taskState.delete(taskID);
+        }
+      }
+      startTaskPoll(payload.active_task_id);
+    } else {
+      for (const taskID of Array.from(taskPollers.keys())) {
         stopTaskPoll(taskID);
         taskState.delete(taskID);
       }
     }
-  } catch (error) {}
+  } catch (error) {
+    toast('Network error', 'error');
+  }
 }
 
 async function pollTask(taskID) {
@@ -184,7 +217,7 @@ async function pollTask(taskID) {
     if (!response.ok) return;
     const task = await response.json();
     taskState.set(taskID, task);
-    renderDisks();
+    renderDisk();
 
     if (['success', 'failed', 'canceled'].includes(task.status)) {
       stopTaskPoll(taskID);
@@ -192,17 +225,19 @@ async function pollTask(taskID) {
       if (task.status === 'success') toast(task.message || 'Done', 'ok');
       if (task.status === 'failed') toast('Error: ' + task.error, 'error');
       if (task.status === 'canceled') toast('Copy canceled', 'error');
-      refreshDisks();
+      refreshSelectedDisk();
     }
   } catch (error) {}
 }
 
-async function startCopy(diskID, mode) {
+async function startCopy(mode) {
+  const mountPath = document.getElementById('mountPath').value.trim();
+  if (!mountPath) return;
   try {
-    const response = await fetch('/api/disks/' + encodeURIComponent(diskID) + '/copy/start', {
+    const response = await fetch('/api/disks/copy/start', {
       method: 'POST',
       headers: { 'Content-Type': 'application/json' },
-      body: JSON.stringify({ mode })
+      body: JSON.stringify({ mount_path: mountPath, mode })
     });
     const payload = await response.json();
     if (!response.ok) {
@@ -210,22 +245,25 @@ async function startCopy(diskID, mode) {
       return;
     }
     startTaskPoll(payload.task_id);
-    refreshDisks();
+    refreshSelectedDisk();
   } catch (error) {
     toast('Network error', 'error');
   }
 }
 
-async function cancelCopy(diskID) {
+async function cancelCopy() {
+  if (!selectedDisk.info || !selectedDisk.info.disk_id) return;
   try {
-    await fetch('/api/disks/' + encodeURIComponent(diskID) + '/copy/cancel', { method: 'POST' });
+    await fetch('/api/disks/' + encodeURIComponent(selectedDisk.info.disk_id) + '/copy/cancel', { method: 'POST' });
     toast('Canceling...', 'ok');
   } catch (error) {
     toast('Network error', 'error');
   }
 }
 
-async function initDisk(mountPath) {
+async function initDisk() {
+  const mountPath = document.getElementById('mountPath').value.trim();
+  if (!mountPath) return;
   try {
     const response = await fetch('/api/disks/init', {
       method: 'POST',
@@ -238,23 +276,28 @@ async function initDisk(mountPath) {
       return;
     }
     toast('Disk initialized', 'ok');
-    refreshDisks();
+    refreshSelectedDisk();
   } catch (error) {
     toast('Network error', 'error');
   }
 }
 
-document.getElementById('diskGrid').addEventListener('click', (event) => {
+document.getElementById('diskState').addEventListener('click', (event) => {
   const button = event.target.closest('button[data-action]');
   if (!button) return;
 
   const action = button.dataset.action;
-  if (action === 'start-copy') startCopy(button.dataset.diskId, button.dataset.mode || 'add');
+  if (action === 'start-copy') startCopy(button.dataset.mode || 'add');
-  if (action === 'cancel-copy') cancelCopy(button.dataset.diskId);
+  if (action === 'cancel-copy') cancelCopy();
-  if (action === 'init-disk') initDisk(button.dataset.mountPath);
+  if (action === 'init-disk') initDisk();
 });
 
-refreshDisks();
+const savedMountPath = localStorage.getItem('jukebox.selectedMountPath');
-setInterval(refreshDisks, 5000);
+if (savedMountPath) {
+  document.getElementById('mountPath').value = savedMountPath;
+  refreshSelectedDisk();
+} else {
+  renderDisk();
+}
 </script>
 {{end}}

web/templates/settings.html

@@ -4,16 +4,17 @@
   <section class="panel">
     <h2>Copy Sources</h2>
     <div class="panel-body">
-      <div class="form-hint">Select top-level folders or expand branches and choose individual nested directories.</div>
+      <div class="form-hint">Add one or more root folders with source files. After that, expand each root and enable or disable individual nested folders with checkboxes.</div>
+    </div>
+    <div class="btn-row">
+      <button type="button" class="button-primary" onclick="addSourceRoot()">Add source folder</button>
+      <button type="button" class="button-secondary button-sm" onclick="reloadAllSourceTrees()">Refresh trees</button>
     </div>
     <div class="source-list">
       <div class="source-tree" id="sourceTree">
-        <div class="text-muted source-tree-empty">Loading...</div>
+        <div class="text-muted source-tree-empty">No source folders added yet.</div>
       </div>
     </div>
-    <div class="btn-row">
-      <button type="button" class="button-secondary button-sm" onclick="reloadSourceTree()">Refresh list</button>
-    </div>
   </section>
 
   <section class="panel">
@@ -77,6 +78,7 @@
 const sourceTree = new Map();
 const expandedNodes = new Set();
 const loadingNodes = new Set();
+let sourceRoots = [];
 let sourceConfig = {};
 
 function escapeHTML(value) {
@@ -89,13 +91,43 @@ function escapeHTML(value) {
   }[char]));
 }
 
-function pathDepth(path) {
+function pathSegments(path) {
-  return path ? path.split('/').length : 0;
+  return String(path || '').split(/[\\/]+/).filter(Boolean);
+}
+
+function nodeName(path) {
+  const parts = pathSegments(path);
+  return parts.length ? parts[parts.length - 1] : path;
+}
+
+function normalizeComparePath(path) {
+  return String(path || '').replace(/\\/g, '/').replace(/\/+$/, '').toLowerCase();
+}
+
+function isSamePath(a, b) {
+  return normalizeComparePath(a) === normalizeComparePath(b);
+}
+
+function isPathWithin(base, candidate) {
+  const baseNorm = normalizeComparePath(base);
+  const candidateNorm = normalizeComparePath(candidate);
+  return candidateNorm === baseNorm || candidateNorm.startsWith(baseNorm + '/');
 }
 
 function parentPath(path) {
-  if (!path || !path.includes('/')) return '';
+  const value = String(path || '').replace(/[\\/]+$/, '');
-  return path.slice(0, path.lastIndexOf('/'));
+  const slash = Math.max(value.lastIndexOf('/'), value.lastIndexOf('\\'));
+  if (slash < 0) return '';
+  if (slash === 2 && /^[A-Za-z]:/.test(value)) return value.slice(0, slash + 1);
+  if (slash === 0) return value.slice(0, 1);
+  return value.slice(0, slash);
+}
+
+function relativeDepth(root, path) {
+  if (isSamePath(root, path)) return 0;
+  const rootParts = pathSegments(root);
+  const pathParts = pathSegments(path);
+  return Math.max(0, pathParts.length - rootParts.length);
 }
 
 function effectiveSourceState(path) {
@@ -104,37 +136,45 @@ function effectiveSourceState(path) {
     if (Object.prototype.hasOwnProperty.call(sourceConfig, current)) {
       return sourceConfig[current];
     }
-    if (!current) return true;
     current = parentPath(current);
+    if (!current) return true;
   }
 }
 
 function collectSourcesForSave() {
   const items = [];
   const seen = new Set();
-  const roots = sourceTree.get('') || [];
 
-  for (const item of roots) {
+  sourceRoots.forEach((root) => {
-    items.push({ path: item.path, enabled: effectiveSourceState(item.path) });
+    items.push({ path: root, enabled: effectiveSourceState(root), root: true });
-    seen.add(item.path);
+    seen.add(normalizeComparePath(root));
-  }
+  });
 
   Object.entries(sourceConfig).forEach(([path, enabled]) => {
-    if (seen.has(path)) return;
+    const key = normalizeComparePath(path);
-    items.push({ path, enabled });
+    if (seen.has(key)) return;
+    items.push({ path, enabled, root: false });
   });
 
   return items.sort((a, b) => a.path.localeCompare(b.path));
 }
 
-async function loadSourceChildren(path = '') {
+async function pickFolder() {
-  if (loadingNodes.has(path)) return;
+  const response = await fetch('/api/system/pick-folder', { method: 'POST' });
+  const payload = await response.json();
+  if (!response.ok) {
+    throw new Error(payload.error || 'Failed to choose folder');
+  }
+  return payload.path || '';
+}
+
+async function loadSourceChildren(path) {
+  if (!path || loadingNodes.has(path)) return;
   loadingNodes.add(path);
   renderSources();
 
   try {
-    const query = path ? '?path=' + encodeURIComponent(path) : '';
+    const response = await fetch('/api/sources?path=' + encodeURIComponent(path));
-    const response = await fetch('/api/sources' + query);
     if (!response.ok) return;
     const payload = await response.json();
     sourceTree.set(path, payload.items || []);
@@ -159,15 +199,59 @@ function toggleSource(path, checked) {
   renderSources();
 }
 
-function renderSourceNodes(parent = '') {
+function removeRoot(path) {
-  const items = sourceTree.get(parent) || [];
+  sourceRoots = sourceRoots.filter((root) => !isSamePath(root, path));
+  sourceTree.delete(path);
+  expandedNodes.delete(path);
+  loadingNodes.delete(path);
+
+  Object.keys(sourceConfig).forEach((key) => {
+    if (isPathWithin(path, key)) {
+      delete sourceConfig[key];
+    }
+  });
+
+  renderSources();
+}
+
+async function addSourceRoot() {
+  try {
+    const path = await pickFolder();
+    if (!path) return;
+    if (sourceRoots.some((root) => isSamePath(root, path))) {
+      toast('This source folder is already added', 'error');
+      return;
+    }
+    sourceRoots.push(path);
+    sourceRoots.sort((a, b) => a.localeCompare(b));
+    sourceConfig[path] = true;
+    expandedNodes.add(path);
+    await loadSourceChildren(path);
+  } catch (error) {
+    toast(error.message || 'Failed to choose folder', 'error');
+  }
+}
+
+async function reloadAllSourceTrees() {
+  const roots = [...sourceRoots];
+  sourceTree.clear();
+  for (const root of roots) {
+    if (expandedNodes.has(root)) {
+      await loadSourceChildren(root);
+    }
+  }
+  renderSources();
+}
+
+function renderSourceNodes(root, parentPathValue) {
+  const items = sourceTree.get(parentPathValue) || [];
   return items.map((item) => {
     const checked = effectiveSourceState(item.path);
     const expanded = expandedNodes.has(item.path);
     const childrenKnown = sourceTree.has(item.path);
     const children = childrenKnown ? sourceTree.get(item.path) : [];
     const hasChildren = !childrenKnown || children.length > 0;
-    const pad = 16 + pathDepth(item.path) * 20;
+    const pad = 16 + (relativeDepth(root, item.path) + 1) * 20;
 
     return `
       <div class="source-node">
@@ -182,11 +266,11 @@ function renderSourceNodes(parent = '') {
           <input class="source-check" type="checkbox" data-action="toggle-check" data-path="${escapeHTML(item.path)}" ${checked ? 'checked' : ''}>
           <div class="source-label">
             <span class="source-item-name">${escapeHTML(item.name)}</span>
-            <span class="source-item-path">/media/${escapeHTML(item.path)}</span>
+            <span class="source-item-path">${escapeHTML(item.path)}</span>
           </div>
         </div>
         ${expanded && loadingNodes.has(item.path) ? '<div class="source-loading">Loading...</div>' : ''}
-        ${expanded && childrenKnown && children.length ? `<div class="source-children">${renderSourceNodes(item.path)}</div>` : ''}
+        ${expanded && childrenKnown && children.length ? `<div class="source-children">${renderSourceNodes(root, item.path)}</div>` : ''}
       </div>
     `;
   }).join('');
@@ -194,24 +278,54 @@ function renderSourceNodes(parent = '') {
 
 function renderSources() {
   const el = document.getElementById('sourceTree');
-  const roots = sourceTree.get('');
+  if (!sourceRoots.length) {
-
+    el.innerHTML = '<div class="text-muted source-tree-empty">No source folders added yet.</div>';
-  if (loadingNodes.has('') && !roots) {
-    el.innerHTML = '<div class="text-muted source-tree-empty">Loading...</div>';
-    return;
-  }
-  if (!roots || !roots.length) {
-    el.innerHTML = '<div class="text-muted source-tree-empty">No folders found in /media.</div>';
     return;
   }
 
-  el.innerHTML = renderSourceNodes('');
+  el.innerHTML = sourceRoots.map((root) => {
+    const checked = effectiveSourceState(root);
+    const expanded = expandedNodes.has(root);
+    const childrenKnown = sourceTree.has(root);
+    const children = childrenKnown ? sourceTree.get(root) : [];
+    const hasChildren = !childrenKnown || children.length > 0;
+
+    return `
+      <div class="source-root-card">
+        <div class="source-row source-root-row">
+          <button
+            type="button"
+            class="source-toggle ${hasChildren ? '' : 'source-toggle-empty'}"
+            data-action="toggle-expand"
+            data-path="${escapeHTML(root)}"
+            ${hasChildren ? '' : 'tabindex="-1" aria-hidden="true"'}
+          >${expanded ? '▾' : '▸'}</button>
+          <input class="source-check" type="checkbox" data-action="toggle-check" data-path="${escapeHTML(root)}" ${checked ? 'checked' : ''}>
+          <div class="source-label">
+            <div class="source-root-title">
+              <span class="source-item-name">${escapeHTML(nodeName(root))}</span>
+              <span class="source-root-badge">Root</span>
+            </div>
+            <span class="source-item-path">${escapeHTML(root)}</span>
+          </div>
+          <button type="button" class="button-secondary button-sm" data-action="remove-root" data-path="${escapeHTML(root)}">Remove</button>
+        </div>
+        ${expanded && loadingNodes.has(root) ? '<div class="source-loading">Loading...</div>' : ''}
+        ${expanded && childrenKnown && children.length ? `<div class="source-children">${renderSourceNodes(root, root)}</div>` : ''}
+      </div>
+    `;
+  }).join('');
 }
 
-async function reloadSourceTree() {
+function deriveRootsFromSources(sources) {
-  sourceTree.clear();
+  const explicitRoots = sources.filter((source) => source.root).map((source) => source.path);
-  expandedNodes.clear();
+  if (explicitRoots.length) {
-  await loadSourceChildren('');
+    return explicitRoots;
+  }
+
+  return sources
+    .map((source) => source.path)
+    .filter((path, index, all) => !all.some((other, otherIndex) => otherIndex !== index && isPathWithin(other, path) && !isSamePath(other, path)));
 }
 
 async function loadSettings() {
@@ -229,7 +343,10 @@ async function loadSettings() {
     (cfg.sources || []).forEach((source) => {
       sourceConfig[source.path] = !!source.enabled;
     });
-    renderSources();
+    sourceRoots = deriveRootsFromSources(cfg.sources || []).sort((a, b) => a.localeCompare(b));
+    expandedNodes.clear();
+    sourceTree.clear();
+    await reloadAllSourceTrees();
   } catch (error) {}
 }
 
@@ -264,16 +381,22 @@ async function saveSettings(event) {
 }
 
 document.getElementById('sourceTree').addEventListener('click', async (event) => {
-  const button = event.target.closest('[data-action="toggle-expand"]');
+  const button = event.target.closest('button[data-action]');
   if (!button) return;
 
+  const action = button.dataset.action;
   const path = button.dataset.path;
-  if (expandedNodes.has(path)) {
+  if (action === 'toggle-expand') {
-    expandedNodes.delete(path);
+    if (expandedNodes.has(path)) {
-    renderSources();
+      expandedNodes.delete(path);
-    return;
+      renderSources();
+      return;
+    }
+    await ensureExpanded(path);
+  }
+  if (action === 'remove-root') {
+    removeRoot(path);
   }
-  await ensureExpanded(path);
 });
 
 document.getElementById('sourceTree').addEventListener('change', (event) => {
@@ -283,6 +406,5 @@ document.getElementById('sourceTree').addEventListener('change', (event) => {
 });
 
 loadSettings();
-loadSourceChildren('');
 </script>
 {{end}}