Address code review feedback: add validation and improve error handling

Co-authored-by: krau <71133316+krau@users.noreply.github.com>

Dockerfile

@@ -26,7 +26,7 @@ RUN --mount=type=cache,target=/root/.cache/go-build \
 
 FROM alpine:latest
 
-RUN apk add --no-cache curl ffmpeg
+RUN apk add --no-cache curl ffmpeg yt-dlp
 
 WORKDIR /app
 

README.md

@@ -26,6 +26,9 @@
 - Multi-user support
 - Auto organize files based on storage rules
 - Watch specified chats and auto-save messages, with filters
+- Transfer files between different storage backends
+- Integrate with yt-dlp to download and save media from 1000+ websites
+- Aria2 integration to download files from URLs/magnets and save to storages
 - Write JS parser plugins to save files from almost any website
 - Storage backends:
   - Alist

README_zh.md

@@ -24,6 +24,9 @@
 - 多用户使用
 - 基于存储规则的自动整理
 - 监听并自动转存指定聊天的消息, 支持过滤
+- 在不同存储端之间转存文件
+- 集成 yt-dlp, 从所支持的网站下载并转存媒体文件
+- 集成 Aria2, 支持直链/磁力下载和转存
 - 使用 js 编写解析器插件以转存任意网站的文件
 - 存储端支持:
   - Alist

api/handlers.go

@@ -1,629 +0,0 @@
-package api
-
-import (
-	"bytes"
-	"context"
-	"encoding/json"
-	"fmt"
-	"io"
-	"math"
-	"net/http"
-	"net/url"
-	"path"
-	"strings"
-	"sync"
-	"sync/atomic"
-	"time"
-
-	"github.com/celestix/gotgproto/ext"
-	"github.com/charmbracelet/log"
-	"github.com/gotd/td/tg"
-	"github.com/krau/SaveAny-Bot/client/bot"
-	"github.com/krau/SaveAny-Bot/client/bot/handlers/utils/ruleutil"
-	"github.com/krau/SaveAny-Bot/common/utils/tgutil"
-	"github.com/krau/SaveAny-Bot/config"
-	"github.com/krau/SaveAny-Bot/core"
-	tftask "github.com/krau/SaveAny-Bot/core/tasks/tfile"
-	"github.com/krau/SaveAny-Bot/database"
-	"github.com/krau/SaveAny-Bot/pkg/queue"
-	"github.com/krau/SaveAny-Bot/pkg/tfile"
-	"github.com/krau/SaveAny-Bot/storage"
-	"github.com/rs/xid"
-)
-
-// Request/Response types
-type CreateTaskRequest struct {
-	TelegramURL string `json:"telegram_url"`
-	StorageName string `json:"storage_name,omitempty"`
-	DirPath     string `json:"dir_path,omitempty"`
-	UserID      int64  `json:"user_id"`
-}
-
-type CreateTaskResponse struct {
-	TaskID  string `json:"task_id"`
-	Message string `json:"message"`
-}
-
-type TaskStatusResponse struct {
-	TaskID      string    `json:"task_id"`
-	Status      string    `json:"status"` // queued, running, completed, failed, canceled
-	Title       string    `json:"title"`
-	CreatedAt   time.Time `json:"created_at"`
-	Error       string    `json:"error,omitempty"`
-	Downloaded  int64     `json:"downloaded,omitempty"`   // Bytes downloaded
-	Total       int64     `json:"total,omitempty"`        // Total bytes
-	ProgressPct float64   `json:"progress_pct,omitempty"` // Progress percentage (0-100)
-}
-
-type ListTasksResponse struct {
-	Queued  []TaskInfo `json:"queued"`
-	Running []TaskInfo `json:"running"`
-}
-
-type TaskInfo struct {
-	ID    string `json:"id"`
-	Title string `json:"title"`
-}
-
-type ErrorResponse struct {
-	Error string `json:"error"`
-}
-
-// Task tracking
-var (
-	taskStatuses   = make(map[string]*taskStatus)
-	taskStatusesMu sync.RWMutex
-)
-
-type taskStatus struct {
-	ID          string
-	Status      string
-	Title       string
-	CreatedAt   time.Time
-	Error       string
-	Downloaded  atomic.Int64 // Use atomic for lock-free updates
-	Total       atomic.Int64 // Use atomic for lock-free updates
-	ProgressPct uint64       // Store as uint64 bits of float64 for atomic access
-}
-
-func handleHealth(w http.ResponseWriter, r *http.Request) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusOK)
-	json.NewEncoder(w).Encode(map[string]string{"status": "ok"})
-}
-
-func handleCreateTask(w http.ResponseWriter, r *http.Request) {
-	var req CreateTaskRequest
-	if err := json.NewDecoder(r.Body).Decode(&req); err != nil {
-		respondError(w, "invalid request body", http.StatusBadRequest)
-		return
-	}
-
-	// Validate request
-	if req.TelegramURL == "" {
-		respondError(w, "telegram_url is required", http.StatusBadRequest)
-		return
-	}
-	if req.UserID <= 0 {
-		respondError(w, "user_id is required and must be positive", http.StatusBadRequest)
-		return
-	}
-
-	logger := log.FromContext(r.Context()).WithPrefix("api")
-
-	// Get user from database
-	userDB, err := database.GetUserByChatID(r.Context(), req.UserID)
-	if err != nil {
-		logger.Errorf("Failed to get user: %v", err)
-		respondError(w, "user not found", http.StatusBadRequest)
-		return
-	}
-
-	// Get storage
-	var stor storage.Storage
-	if req.StorageName != "" {
-		stor, err = storage.GetStorageByUserIDAndName(r.Context(), req.UserID, req.StorageName)
-		if err != nil {
-			logger.Errorf("Failed to get storage: %v", err)
-			respondError(w, "storage not found", http.StatusBadRequest)
-			return
-		}
-	} else {
-		// Use first available storage for the user
-		storages := storage.GetUserStorages(r.Context(), req.UserID)
-		if len(storages) == 0 {
-			respondError(w, "no storage available for user", http.StatusBadRequest)
-			return
-		}
-		stor = storages[0]
-	}
-
-	// Parse Telegram URL
-	botCtx := bot.ExtContext()
-	if botCtx == nil {
-		respondError(w, "bot not initialized", http.StatusInternalServerError)
-		return
-	}
-
-	linkUrl, err := url.Parse(req.TelegramURL)
-	if err != nil {
-		logger.Errorf("Failed to parse URL: %v", err)
-		respondError(w, "invalid telegram URL format", http.StatusBadRequest)
-		return
-	}
-
-	chatID, msgID, err := tgutil.ParseMessageLink(botCtx, req.TelegramURL)
-	if err != nil {
-		logger.Errorf("Failed to parse Telegram URL: %v", err)
-		respondError(w, "invalid telegram URL format", http.StatusBadRequest)
-		return
-	}
-
-	// Get message from Telegram
-	msg, err := tgutil.GetMessageByID(botCtx, chatID, msgID)
-	if err != nil {
-		logger.Errorf("Failed to get message: %v", err)
-		respondError(w, "failed to retrieve message", http.StatusBadRequest)
-		return
-	}
-
-	// Check if message has media
-	media, ok := msg.GetMedia()
-	if !ok {
-		respondError(w, "message has no media", http.StatusBadRequest)
-		return
-	}
-
-	// Collect files - handle both single and grouped messages
-	files := make([]tfile.TGFileMessage, 0)
-
-	// Check for grouped messages (media group)
-	groupID, isGroup := msg.GetGroupedID()
-	if isGroup && groupID != 0 && !linkUrl.Query().Has("single") {
-		// Handle media group
-		gmsgs, err := tgutil.GetGroupedMessages(botCtx, chatID, msg)
-		if err != nil {
-			logger.Errorf("Failed to get grouped messages: %v", err)
-			// Fall back to single message
-			file, err := createTGFileWithMedia(botCtx, msg, media, userDB)
-			if err != nil {
-				logger.Errorf("Failed to create TGFile: %v", err)
-				respondError(w, "invalid message format", http.StatusBadRequest)
-				return
-			}
-			files = append(files, file)
-		} else {
-			// Process all messages in the group
-			for _, gmsg := range gmsgs {
-				if gmsg.Media == nil {
-					continue
-				}
-				gMedia, ok := gmsg.GetMedia()
-				if !ok {
-					continue
-				}
-				file, err := createTGFileWithMedia(botCtx, gmsg, gMedia, userDB)
-				if err != nil {
-					logger.Warnf("Failed to create TGFile for grouped message: %v", err)
-					continue
-				}
-				files = append(files, file)
-			}
-		}
-	} else {
-		// Single message
-		file, err := createTGFileWithMedia(botCtx, msg, media, userDB)
-		if err != nil {
-			logger.Errorf("Failed to create TGFile: %v", err)
-			respondError(w, "invalid message format", http.StatusBadRequest)
-			return
-		}
-		files = append(files, file)
-	}
-
-	if len(files) == 0 {
-		respondError(w, "no savable files found", http.StatusBadRequest)
-		return
-	}
-
-	// Create tasks for all files with proper album handling
-	taskIDs := make([]string, 0, len(files))
-	baseDirPath := req.DirPath
-	if baseDirPath == "" {
-		baseDirPath = "/"
-	}
-
-	// Create context with bot extension
-	injectCtx := tgutil.ExtWithContext(r.Context(), botCtx)
-
-	// Apply storage rules if enabled for the user
-	useRule := userDB.ApplyRule && userDB.Rules != nil
-
-	// Helper to apply rules to a file
-	applyRule := func(file tfile.TGFileMessage) (storage.Storage, ruleutil.MatchedDirPath) {
-		fileStor := stor
-		dirPath := ruleutil.MatchedDirPath(baseDirPath)
-		
-		if useRule {
-			matched, matchedStorName, matchedDirPath := ruleutil.ApplyRule(injectCtx, userDB.Rules, ruleutil.NewInput(file))
-			if matched {
-				// Rule matched, apply overrides
-				if matchedDirPath != "" {
-					dirPath = matchedDirPath
-				}
-				if matchedStorName.Usable() {
-					var err error
-					fileStor, err = storage.GetStorageByUserIDAndName(injectCtx, userDB.ChatID, matchedStorName.String())
-					if err != nil {
-						logger.Errorf("Failed to get storage from rule: %v", err)
-						// Fall back to original storage
-						fileStor = stor
-					}
-				}
-			}
-		}
-		return fileStor, dirPath
-	}
-
-	// Separate files into regular and album files
-	type albumFile struct {
-		file    tfile.TGFileMessage
-		storage storage.Storage
-		dirPath ruleutil.MatchedDirPath
-	}
-	albumFiles := make(map[int64][]albumFile)
-	
-	for _, tgFile := range files {
-		fileStor, dirPath := applyRule(tgFile)
-		
-		// Check if this needs album handling (NEW-FOR-ALBUM rule)
-		if dirPath.NeedNewForAlbum() {
-			groupId, isGroup := tgFile.Message().GetGroupedID()
-			if !isGroup || groupId == 0 {
-				logger.Warnf("File %s has NEW-FOR-ALBUM rule but is not in a group, treating as regular file", tgFile.Name())
-				// Treat as regular file with base dir path
-				storagePath := fileStor.JoinStoragePath(path.Join(baseDirPath, tgFile.Name()))
-				taskID := xid.New().String()
-
-				task, err := tftask.NewTGFileTask(taskID, injectCtx, tgFile, fileStor, storagePath, &apiProgressTracker{
-					taskID: taskID,
-				})
-				if err != nil {
-					logger.Errorf("Failed to create task: %v", err)
-					respondError(w, "failed to create task", http.StatusInternalServerError)
-					return
-				}
-
-				trackTask(taskID, task.Title(), "queued")
-				if err := core.AddTask(injectCtx, task); err != nil {
-					logger.Errorf("Failed to add task: %v", err)
-					updateTaskStatus(taskID, "failed", err.Error())
-					respondError(w, "failed to add task to queue", http.StatusInternalServerError)
-					return
-				}
-
-				taskIDs = append(taskIDs, taskID)
-				continue
-			}
-			
-			// Group by album ID
-			if _, ok := albumFiles[groupId]; !ok {
-				albumFiles[groupId] = make([]albumFile, 0)
-			}
-			albumFiles[groupId] = append(albumFiles[groupId], albumFile{
-				file:    tgFile,
-				storage: fileStor,
-				dirPath: dirPath,
-			})
-		} else {
-			// Regular file - create task immediately
-			storagePath := fileStor.JoinStoragePath(path.Join(dirPath.String(), tgFile.Name()))
-			taskID := xid.New().String()
-
-			task, err := tftask.NewTGFileTask(taskID, injectCtx, tgFile, fileStor, storagePath, &apiProgressTracker{
-				taskID: taskID,
-			})
-			if err != nil {
-				logger.Errorf("Failed to create task: %v", err)
-				respondError(w, "failed to create task", http.StatusInternalServerError)
-				return
-			}
-
-			trackTask(taskID, task.Title(), "queued")
-			if err := core.AddTask(injectCtx, task); err != nil {
-				logger.Errorf("Failed to add task: %v", err)
-				updateTaskStatus(taskID, "failed", err.Error())
-				respondError(w, "failed to add task to queue", http.StatusInternalServerError)
-				return
-			}
-
-			taskIDs = append(taskIDs, taskID)
-		}
-	}
-
-	// Handle album files - group them into subdirectories
-	for _, afiles := range albumFiles {
-		if len(afiles) <= 1 {
-			// Single file in album, treat as regular
-			for _, af := range afiles {
-				storagePath := af.storage.JoinStoragePath(path.Join(baseDirPath, af.file.Name()))
-				taskID := xid.New().String()
-
-				task, err := tftask.NewTGFileTask(taskID, injectCtx, af.file, af.storage, storagePath, &apiProgressTracker{
-					taskID: taskID,
-				})
-				if err != nil {
-					logger.Errorf("Failed to create task: %v", err)
-					respondError(w, "failed to create task", http.StatusInternalServerError)
-					return
-				}
-
-				trackTask(taskID, task.Title(), "queued")
-				if err := core.AddTask(injectCtx, task); err != nil {
-					logger.Errorf("Failed to add task: %v", err)
-					updateTaskStatus(taskID, "failed", err.Error())
-					respondError(w, "failed to add task to queue", http.StatusInternalServerError)
-					return
-				}
-
-				taskIDs = append(taskIDs, taskID)
-			}
-			continue
-		}
-
-		// Multiple files in album - create subdirectory named after first file
-		// Remove extension from first file's name to use as directory name
-		albumDir := strings.TrimSuffix(path.Base(afiles[0].file.Name()), path.Ext(afiles[0].file.Name()))
-		albumStor := afiles[0].storage
-
-		for _, af := range afiles {
-			// All files go into the album subdirectory
-			storagePath := albumStor.JoinStoragePath(path.Join(baseDirPath, albumDir, af.file.Name()))
-			taskID := xid.New().String()
-
-			task, err := tftask.NewTGFileTask(taskID, injectCtx, af.file, albumStor, storagePath, &apiProgressTracker{
-				taskID: taskID,
-			})
-			if err != nil {
-				logger.Errorf("Failed to create task for album file: %v", err)
-				respondError(w, "failed to create task", http.StatusInternalServerError)
-				return
-			}
-
-			trackTask(taskID, task.Title(), "queued")
-			if err := core.AddTask(injectCtx, task); err != nil {
-				logger.Errorf("Failed to add task: %v", err)
-				updateTaskStatus(taskID, "failed", err.Error())
-				respondError(w, "failed to add task to queue", http.StatusInternalServerError)
-				return
-			}
-
-			taskIDs = append(taskIDs, taskID)
-		}
-	}
-
-	// Send success response
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(http.StatusCreated)
-
-	// Return first task ID for single file, or all task IDs for media group
-	if len(taskIDs) == 1 {
-		json.NewEncoder(w).Encode(CreateTaskResponse{
-			TaskID:  taskIDs[0],
-			Message: "task created successfully",
-		})
-	} else {
-		json.NewEncoder(w).Encode(map[string]interface{}{
-			"task_ids": taskIDs,
-			"message":  fmt.Sprintf("%d tasks created successfully", len(taskIDs)),
-		})
-	}
-}
-
-// createTGFileWithMedia creates a TGFile with proper filename handling using user's strategy
-func createTGFileWithMedia(botCtx *ext.Context, msg *tg.Message, media tg.MessageMediaClass, userDB *database.User) (tfile.TGFileMessage, error) {
-	// Use the same filename generation logic as bot handlers
-	opts := []tfile.TGFileOption{tfile.WithNameIfEmpty(tgutil.GenFileNameFromMessage(*msg))}
-	return tfile.FromMediaMessage(media, botCtx.Raw, msg, opts...)
-}
-
-func handleGetTask(w http.ResponseWriter, r *http.Request) {
-	taskID := r.PathValue("id")
-	if taskID == "" {
-		respondError(w, "task_id is required", http.StatusBadRequest)
-		return
-	}
-
-	taskStatusesMu.RLock()
-	status, exists := taskStatuses[taskID]
-	taskStatusesMu.RUnlock()
-
-	if !exists {
-		respondError(w, "task not found", http.StatusNotFound)
-		return
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(TaskStatusResponse{
-		TaskID:      status.ID,
-		Status:      status.Status,
-		Title:       status.Title,
-		CreatedAt:   status.CreatedAt,
-		Error:       status.Error,
-		Downloaded:  status.Downloaded.Load(),
-		Total:       status.Total.Load(),
-		ProgressPct: math.Float64frombits(atomic.LoadUint64((*uint64)(&status.ProgressPct))),
-	})
-}
-
-func handleListTasks(w http.ResponseWriter, r *http.Request) {
-	queued := core.GetQueuedTasks(r.Context())
-	running := core.GetRunningTasks(r.Context())
-
-	response := ListTasksResponse{
-		Queued:  convertTaskInfos(queued),
-		Running: convertTaskInfos(running),
-	}
-
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(response)
-}
-
-func handleCancelTask(w http.ResponseWriter, r *http.Request) {
-	taskID := r.PathValue("id")
-	if taskID == "" {
-		respondError(w, "task_id is required", http.StatusBadRequest)
-		return
-	}
-
-	if err := core.CancelTask(r.Context(), taskID); err != nil {
-		log.FromContext(r.Context()).Errorf("Failed to cancel task %s: %v", taskID, err)
-		respondError(w, "failed to cancel task", http.StatusInternalServerError)
-		return
-	}
-
-	updateTaskStatus(taskID, "canceled", "")
-
-	w.Header().Set("Content-Type", "application/json")
-	json.NewEncoder(w).Encode(map[string]string{"message": "task canceled"})
-}
-
-// Helper functions
-
-func respondError(w http.ResponseWriter, message string, statusCode int) {
-	w.Header().Set("Content-Type", "application/json")
-	w.WriteHeader(statusCode)
-	json.NewEncoder(w).Encode(ErrorResponse{Error: message})
-}
-
-func trackTask(taskID, title, status string) {
-	taskStatusesMu.Lock()
-	defer taskStatusesMu.Unlock()
-	taskStatuses[taskID] = &taskStatus{
-		ID:        taskID,
-		Status:    status,
-		Title:     title,
-		CreatedAt: time.Now(),
-	}
-}
-
-func updateTaskStatus(taskID, status, errorMsg string) {
-	taskStatusesMu.Lock()
-	defer taskStatusesMu.Unlock()
-	if ts, exists := taskStatuses[taskID]; exists {
-		ts.Status = status
-		ts.Error = errorMsg
-	}
-}
-
-func convertTaskInfos(tasks []queue.TaskInfo) []TaskInfo {
-	result := make([]TaskInfo, len(tasks))
-	for i, t := range tasks {
-		result[i] = TaskInfo{
-			ID:    t.ID,
-			Title: t.Title,
-		}
-	}
-	return result
-}
-
-// apiProgressTracker implements tftask.ProgressTracker for API tasks
-type apiProgressTracker struct {
-	taskID string
-}
-
-func (a *apiProgressTracker) OnStart(ctx context.Context, info tftask.TaskInfo) {
-	updateTaskStatus(a.taskID, "running", "")
-}
-
-func (a *apiProgressTracker) OnProgress(ctx context.Context, info tftask.TaskInfo, downloaded int64, total int64) {
-	// Use atomic operations to avoid mutex locks for better performance
-	// OnProgress is called very frequently during downloads
-	taskStatusesMu.RLock()
-	ts, exists := taskStatuses[a.taskID]
-	taskStatusesMu.RUnlock()
-	
-	if exists {
-		ts.Downloaded.Store(downloaded)
-		ts.Total.Store(total)
-		if total > 0 {
-			progressPct := float64(downloaded) / float64(total) * 100.0
-			atomic.StoreUint64((*uint64)(&ts.ProgressPct), math.Float64bits(progressPct))
-		}
-	}
-}
-
-func (a *apiProgressTracker) OnDone(ctx context.Context, info tftask.TaskInfo, err error) {
-	if err != nil {
-		updateTaskStatus(a.taskID, "failed", err.Error())
-		sendWebhook(a.taskID, "failed", err.Error())
-	} else {
-		updateTaskStatus(a.taskID, "completed", "")
-		sendWebhook(a.taskID, "completed", "")
-	}
-}
-
-// sendWebhook sends a callback to the configured webhook URL
-func sendWebhook(taskID, status, errorMsg string) {
-	cfg := config.C()
-	if cfg.API.WebhookURL == "" {
-		return
-	}
-
-	taskStatusesMu.RLock()
-	ts, exists := taskStatuses[taskID]
-	taskStatusesMu.RUnlock()
-
-	if !exists {
-		return
-	}
-
-	logger := log.WithPrefix("webhook")
-
-	payload := TaskStatusResponse{
-		TaskID:      ts.ID,
-		Status:      status,
-		Title:       ts.Title,
-		CreatedAt:   ts.CreatedAt,
-		Error:       errorMsg,
-		Downloaded:  ts.Downloaded.Load(),
-		Total:       ts.Total.Load(),
-		ProgressPct: math.Float64frombits(atomic.LoadUint64((*uint64)(&ts.ProgressPct))),
-	}
-
-	body, err := json.Marshal(payload)
-	if err != nil {
-		logger.Errorf("Failed to marshal webhook payload: %v", err)
-		return
-	}
-
-	ctx, cancel := context.WithTimeout(context.Background(), 10*time.Second)
-	defer cancel()
-
-	req, err := http.NewRequestWithContext(ctx, "POST", cfg.API.WebhookURL, bytes.NewReader(body))
-	if err != nil {
-		logger.Errorf("Failed to create webhook request: %v", err)
-		return
-	}
-
-	req.Header.Set("Content-Type", "application/json")
-	if cfg.API.Token != "" {
-		req.Header.Set("Authorization", "Bearer "+cfg.API.Token)
-	}
-
-	resp, err := http.DefaultClient.Do(req)
-	if err != nil {
-		logger.Errorf("Failed to send webhook: %v", err)
-		return
-	}
-	defer resp.Body.Close()
-
-	if resp.StatusCode >= 400 {
-		body, err := io.ReadAll(resp.Body)
-		if err != nil {
-			logger.Errorf("Webhook returned error status %d, failed to read response body: %v", resp.StatusCode, err)
-		} else {
-			logger.Errorf("Webhook returned error status %d: %s", resp.StatusCode, string(body))
-		}
-	}
-}

api/middleware.go

@@ -1,66 +0,0 @@
-package api
-
-import (
-	"net/http"
-	"strings"
-	"time"
-
-	"github.com/charmbracelet/log"
-	"github.com/krau/SaveAny-Bot/config"
-)
-
-// authMiddleware validates API token
-func authMiddleware(next http.Handler) http.Handler {
-	return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		// Skip auth for health check
-		if r.URL.Path == "/health" {
-			next.ServeHTTP(w, r)
-			return
-		}
-
-		cfg := config.C()
-
-		// Check token if configured
-		if cfg.API.Token != "" {
-			authHeader := r.Header.Get("Authorization")
-			if authHeader == "" {
-				http.Error(w, `{"error":"unauthorized: missing token"}`, http.StatusUnauthorized)
-				return
-			}
-
-			token := strings.TrimPrefix(authHeader, "Bearer ")
-			if token != cfg.API.Token {
-				http.Error(w, `{"error":"unauthorized: invalid token"}`, http.StatusUnauthorized)
-				return
-			}
-		}
-
-		next.ServeHTTP(w, r)
-	})
-}
-
-// loggingMiddleware logs HTTP requests
-func loggingMiddleware(logger *log.Logger) func(http.Handler) http.Handler {
-	return func(next http.Handler) http.Handler {
-		return http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-			start := time.Now()
-
-			// Wrap response writer to capture status code
-			wrapper := &responseWriter{ResponseWriter: w, statusCode: http.StatusOK}
-
-			next.ServeHTTP(wrapper, r)
-
-			logger.Infof("%s %s %d %s", r.Method, r.URL.Path, wrapper.statusCode, time.Since(start))
-		})
-	}
-}
-
-type responseWriter struct {
-	http.ResponseWriter
-	statusCode int
-}
-
-func (rw *responseWriter) WriteHeader(code int) {
-	rw.statusCode = code
-	rw.ResponseWriter.WriteHeader(code)
-}

api/middleware_test.go

@@ -1,47 +0,0 @@
-package api
-
-import (
-	"net/http"
-	"net/http/httptest"
-	"testing"
-)
-
-func TestAuthMiddleware_NoAuth(t *testing.T) {
-	// Create a test handler
-	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-		w.Write([]byte("OK"))
-	})
-
-	// Create request
-	req := httptest.NewRequest("GET", "/api/v1/tasks", nil)
-	rec := httptest.NewRecorder()
-
-	// Apply middleware
-	authMiddleware(handler).ServeHTTP(rec, req)
-
-	// When no token is configured, request should succeed or be unauthorized
-	if rec.Code != http.StatusOK && rec.Code != http.StatusUnauthorized {
-		t.Errorf("Expected status 200 or 401, got %d", rec.Code)
-	}
-}
-
-func TestAuthMiddleware_HealthCheck(t *testing.T) {
-	// Create a test handler
-	handler := http.HandlerFunc(func(w http.ResponseWriter, r *http.Request) {
-		w.WriteHeader(http.StatusOK)
-		w.Write([]byte("OK"))
-	})
-
-	// Create request to health endpoint
-	req := httptest.NewRequest("GET", "/health", nil)
-	rec := httptest.NewRecorder()
-
-	// Apply middleware
-	authMiddleware(handler).ServeHTTP(rec, req)
-
-	// Health check should always work without auth
-	if rec.Code != http.StatusOK {
-		t.Errorf("Expected status 200 for health check, got %d", rec.Code)
-	}
-}

api/server.go

@@ -1,77 +0,0 @@
-package api
-
-import (
-	"context"
-	"fmt"
-	"net/http"
-	"time"
-
-	"github.com/charmbracelet/log"
-	"github.com/krau/SaveAny-Bot/config"
-)
-
-var server *http.Server
-
-// Init initializes and starts the HTTP API server
-func Init(ctx context.Context) error {
-	cfg := config.C()
-	if !cfg.API.Enable {
-		return nil
-	}
-
-	// Validate that token is configured when API is enabled
-	if cfg.API.Token == "" {
-		return fmt.Errorf("API is enabled but token is not configured. Please set 'api.token' in your configuration file for security")
-	}
-
-	logger := log.FromContext(ctx).WithPrefix("api")
-
-	mux := http.NewServeMux()
-
-	// Register API routes
-	registerRoutes(mux)
-
-	// Wrap with middleware
-	handler := loggingMiddleware(logger)(authMiddleware(mux))
-
-	server = &http.Server{
-		Addr:         fmt.Sprintf(":%d", cfg.API.Port),
-		Handler:      handler,
-		ReadTimeout:  15 * time.Second,
-		WriteTimeout: 15 * time.Second,
-		IdleTimeout:  60 * time.Second,
-	}
-
-	go func() {
-		logger.Infof("Starting API server on port %d", cfg.API.Port)
-		if err := server.ListenAndServe(); err != nil && err != http.ErrServerClosed {
-			logger.Errorf("API server error: %v", err)
-		}
-	}()
-
-	// Graceful shutdown on context cancellation
-	go func() {
-		<-ctx.Done()
-		shutdownCtx, cancel := context.WithTimeout(context.Background(), 5*time.Second)
-		defer cancel()
-
-		if err := server.Shutdown(shutdownCtx); err != nil {
-			logger.Errorf("Failed to shutdown API server: %v", err)
-		} else {
-			logger.Info("API server stopped")
-		}
-	}()
-
-	return nil
-}
-
-func registerRoutes(mux *http.ServeMux) {
-	// Health check endpoint (no auth required)
-	mux.HandleFunc("/health", handleHealth)
-
-	// API v1 endpoints
-	mux.HandleFunc("POST /api/v1/tasks", handleCreateTask)
-	mux.HandleFunc("GET /api/v1/tasks/{id}", handleGetTask)
-	mux.HandleFunc("GET /api/v1/tasks", handleListTasks)
-	mux.HandleFunc("DELETE /api/v1/tasks/{id}", handleCancelTask)
-}

client/bot/handlers/add_task.go

@@ -100,7 +100,9 @@ func handleAddCallback(ctx *ext.Context, update *ext.Update) error {
 		}
 		shortcut.CreateAndAddAria2TaskWithEdit(ctx, selectedStorage, dirPath, data.Aria2URIs, client, msgID, userID)
 	case tasktype.TaskTypeYtdlp:
-		shortcut.CreateAndAddYtdlpTaskWithEdit(ctx, selectedStorage, dirPath, data.YtdlpURLs, msgID, userID)
+		shortcut.CreateAndAddYtdlpTaskWithEdit(ctx, selectedStorage, dirPath, data.YtdlpURLs, data.YtdlpFlags, msgID, userID)
+	case tasktype.TaskTypeTransfer:
+		return handleTransferCallback(ctx, userID, selectedStorage, dirPath, data, msgID)
 	default:
 		return fmt.Errorf("unexcept task type: %s", data.TaskType)
 	}

client/bot/handlers/media_group.go

@@ -114,7 +114,7 @@ func processMediaGroup(ctx *ext.Context, update *ext.Update, groupID int64) {
 	if err != nil {
 		logger.Errorf("Failed to build storage selection keyboard: %s", err)
 		ctx.EditMessage(userId, &tg.MessagesEditMessageRequest{
-			ID:      msg.ID,
+			ID: msg.ID,
 			Message: i18n.T(i18nk.BotMsgMediaGroupErrorBuildStorageSelectKeyboardFailed, map[string]any{
 				"Error": err.Error(),
 			}),

client/bot/handlers/register.go

@@ -31,6 +31,7 @@ var CommandHandlers = []DescCommandHandler{
 	{"dl", i18nk.BotMsgCmdDl, handleDlCmd},
 	{"aria2dl", i18nk.BotMsgCmdAria2dl, handleAria2DlCmd},
 	{"ytdlp", i18nk.BotMsgCmdYtdlp, handleYtdlpCmd},
+	{"transfer", i18nk.BotMsgCmdTransfer, handleTransferCmd},
 	{"task", i18nk.BotMsgCmdTask, handleTaskCmd},
 	{"cancel", i18nk.BotMsgCmdCancel, handleCancelCmd},
 	{"config", i18nk.BotMsgCmdConfig, handleConfigCmd},

client/bot/handlers/tasks.go

@@ -38,7 +38,7 @@ func handleTaskCmd(ctx *ext.Context, update *ext.Update) error {
 			return dispatcher.EndGroups
 		}
 		ctx.Reply(update, ext.ReplyTextStyledTextArray([]styling.StyledTextOption{
-				styling.Plain(i18n.T(i18nk.BotMsgTasksCancelRequestedPrefix)),
+			styling.Plain(i18n.T(i18nk.BotMsgTasksCancelRequestedPrefix)),
 			styling.Code(taskID),
 		}), nil)
 	default:

client/bot/handlers/transfer.go

@@ -0,0 +1,257 @@
+package handlers
+
+import (
+	"fmt"
+	"regexp"
+	"strings"
+
+	"github.com/celestix/gotgproto/dispatcher"
+	"github.com/celestix/gotgproto/ext"
+	"github.com/charmbracelet/log"
+	"github.com/gotd/td/tg"
+	"github.com/krau/SaveAny-Bot/client/bot/handlers/utils/msgelem"
+	"github.com/krau/SaveAny-Bot/common/i18n"
+	"github.com/krau/SaveAny-Bot/common/i18n/i18nk"
+	"github.com/krau/SaveAny-Bot/common/utils/strutil"
+	"github.com/krau/SaveAny-Bot/common/utils/tgutil"
+	"github.com/krau/SaveAny-Bot/core"
+	"github.com/krau/SaveAny-Bot/core/tasks/transfer"
+	"github.com/krau/SaveAny-Bot/pkg/enums/tasktype"
+	"github.com/krau/SaveAny-Bot/pkg/storagetypes"
+	"github.com/krau/SaveAny-Bot/pkg/tcbdata"
+	"github.com/krau/SaveAny-Bot/storage"
+	"github.com/rs/xid"
+)
+
+func handleTransferCmd(ctx *ext.Context, update *ext.Update) error {
+	logger := log.FromContext(ctx)
+	args := strutil.ParseArgsRespectQuotes(update.EffectiveMessage.Text)
+
+	if len(args) < 2 {
+		ctx.Reply(update, ext.ReplyTextString(i18n.T(i18nk.BotMsgTransferUsage, nil)), nil)
+		return dispatcher.EndGroups
+	}
+
+	// Parse source: storage_name:/path
+	sourceParts := strings.SplitN(args[1], ":", 2)
+	if len(sourceParts) != 2 {
+		ctx.Reply(update, ext.ReplyTextString(i18n.T(i18nk.BotMsgTransferErrorInvalidSource, nil)), nil)
+		return dispatcher.EndGroups
+	}
+	sourceStorageName := sourceParts[0]
+	sourcePath := sourceParts[1]
+
+	userID := update.GetUserChat().GetID()
+
+	// Get source storage
+	sourceStorage, err := storage.GetStorageByUserIDAndName(ctx, userID, sourceStorageName)
+	if err != nil {
+		logger.Errorf("Failed to get source storage by user ID and name: %s", err)
+		ctx.Reply(update, ext.ReplyTextString(i18n.T(i18nk.BotMsgTransferErrorStorageNotFound, map[string]any{
+			"StorageName": sourceStorageName,
+			"Error":       err,
+		})), nil)
+		return dispatcher.EndGroups
+	}
+
+	// Check if source storage supports listing
+	listable, ok := sourceStorage.(storage.StorageListable)
+	if !ok {
+		ctx.Reply(update, ext.ReplyTextString(i18n.T(i18nk.BotMsgTransferErrorStorageNotListable, map[string]any{
+			"StorageName": sourceStorageName,
+		})), nil)
+		return dispatcher.EndGroups
+	}
+
+	// Check if source storage supports reading
+	_, ok = sourceStorage.(storage.StorageReadable)
+	if !ok {
+		ctx.Reply(update, ext.ReplyTextString(i18n.T(i18nk.BotMsgTransferErrorStorageNotReadable, map[string]any{
+			"StorageName": sourceStorageName,
+		})), nil)
+		return dispatcher.EndGroups
+	}
+
+	// Fetch file list
+	replied, err := ctx.Reply(update, ext.ReplyTextString(i18n.T(i18nk.BotMsgTransferInfoFetchingFiles, nil)), nil)
+	if err != nil {
+		logger.Errorf("Failed to reply: %s", err)
+		return dispatcher.EndGroups
+	}
+
+	files, err := listable.ListFiles(ctx, sourcePath)
+	if err != nil {
+		ctx.EditMessage(update.EffectiveChat().GetID(), &tg.MessagesEditMessageRequest{
+			ID:      replied.ID,
+			Message: i18n.T(i18nk.BotMsgTransferErrorListFilesFailed, map[string]any{"Error": err}),
+		})
+		return dispatcher.EndGroups
+	}
+
+	// Optional filter
+	var filter *regexp.Regexp
+	if len(args) >= 3 {
+		filter, err = regexp.Compile(args[2])
+		if err != nil {
+			ctx.EditMessage(update.EffectiveChat().GetID(), &tg.MessagesEditMessageRequest{
+				ID:      replied.ID,
+				Message: i18n.T(i18nk.BotMsgTransferErrorInvalidRegex, map[string]any{"Error": err}),
+			})
+			return dispatcher.EndGroups
+		}
+	}
+
+	// Filter files
+	filteredFiles := make([]storagetypes.FileInfo, 0)
+	for _, file := range files {
+		if file.IsDir {
+			continue
+		}
+		if filter != nil && !filter.MatchString(file.Name) {
+			continue
+		}
+		filteredFiles = append(filteredFiles, file)
+	}
+
+	if len(filteredFiles) == 0 {
+		ctx.EditMessage(update.EffectiveChat().GetID(), &tg.MessagesEditMessageRequest{
+			ID:      replied.ID,
+			Message: i18n.T(i18nk.BotMsgTransferErrorNoFilesToTransfer, nil),
+		})
+		return dispatcher.EndGroups
+	}
+
+	// Prepare file paths for callback data
+	filePaths := make([]string, 0, len(filteredFiles))
+	var totalSize int64
+	for _, file := range filteredFiles {
+		filePaths = append(filePaths, file.Path)
+		totalSize += file.Size
+	}
+
+	// Build storage selection keyboard
+	markup, err := msgelem.BuildAddSelectStorageKeyboard(storage.GetUserStorages(ctx, userID), tcbdata.Add{
+		TaskType:               tasktype.TaskTypeTransfer,
+		TransferSourceStorName: sourceStorageName,
+		TransferSourcePath:     sourcePath,
+		TransferFiles:          filePaths,
+	})
+	if err != nil {
+		logger.Errorf("Failed to build storage selection keyboard: %s", err)
+		ctx.EditMessage(update.EffectiveChat().GetID(), &tg.MessagesEditMessageRequest{
+			ID:      replied.ID,
+			Message: i18n.T(i18nk.BotMsgTransferErrorBuildStorageSelectKeyboardFailed, map[string]any{"Error": err}),
+		})
+		return dispatcher.EndGroups
+	}
+
+	ctx.EditMessage(update.EffectiveChat().GetID(), &tg.MessagesEditMessageRequest{
+		ID: replied.ID,
+		Message: i18n.T(i18nk.BotMsgTransferInfoFilesSelectStorage, map[string]any{
+			"Count":  len(filteredFiles),
+			"SizeMB": fmt.Sprintf("%.2f", float64(totalSize)/(1024*1024)),
+		}),
+		ReplyMarkup: markup,
+	})
+
+	return dispatcher.EndGroups
+}
+
+func handleTransferCallback(ctx *ext.Context, userID int64, targetStorage storage.Storage, dirPath string, data tcbdata.Add, msgID int) error {
+	logger := log.FromContext(ctx)
+
+	// Get source storage
+	sourceStorage, err := storage.GetStorageByUserIDAndName(ctx, userID, data.TransferSourceStorName)
+	if err != nil {
+		logger.Errorf("Failed to get source storage: %s", err)
+		ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
+			ID:      msgID,
+			Message: i18n.T(i18nk.BotMsgTransferErrorStorageNotFound, map[string]any{"StorageName": data.TransferSourceStorName, "Error": err}),
+		})
+		return dispatcher.EndGroups
+	}
+
+	// Check if source storage supports listing
+	listable, ok := sourceStorage.(storage.StorageListable)
+	if !ok {
+		ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
+			ID:      msgID,
+			Message: i18n.T(i18nk.BotMsgTransferErrorStorageNotListable, map[string]any{"StorageName": data.TransferSourceStorName}),
+		})
+		return dispatcher.EndGroups
+	}
+
+	// Re-fetch files to get FileInfo (since we only stored paths)
+	// This is necessary to get size and other metadata
+	ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
+		ID:      msgID,
+		Message: i18n.T(i18nk.BotMsgTransferInfoFetchingFiles, nil),
+	})
+
+	allFiles, err := listable.ListFiles(ctx, data.TransferSourcePath)
+	if err != nil {
+		ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
+			ID:      msgID,
+			Message: i18n.T(i18nk.BotMsgTransferErrorListFilesFailed, map[string]any{"Error": err}),
+		})
+		return dispatcher.EndGroups
+	}
+
+	// Create a map for quick lookup
+	fileMap := make(map[string]storagetypes.FileInfo)
+	for _, file := range allFiles {
+		fileMap[file.Path] = file
+	}
+
+	// Build task elements for the selected files
+	elems := make([]transfer.TaskElement, 0, len(data.TransferFiles))
+	var totalSize int64
+	for _, filePath := range data.TransferFiles {
+		fileInfo, ok := fileMap[filePath]
+		if !ok {
+			logger.Warnf("File not found in source storage: %s", filePath)
+			continue
+		}
+		elem := transfer.NewTaskElement(sourceStorage, fileInfo, targetStorage, dirPath)
+		elems = append(elems, *elem)
+		totalSize += fileInfo.Size
+	}
+
+	if len(elems) == 0 {
+		ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
+			ID:      msgID,
+			Message: i18n.T(i18nk.BotMsgTransferErrorNoFilesToTransfer, nil),
+		})
+		return dispatcher.EndGroups
+	}
+
+	// Create and add task
+	taskID := xid.New().String()
+	injectCtx := tgutil.ExtWithContext(ctx.Context, ctx)
+	task := transfer.NewTransferTask(
+		taskID,
+		injectCtx,
+		elems,
+		transfer.NewProgressTracker(msgID, userID),
+		true, // IgnoreErrors
+	)
+
+	if err := core.AddTask(injectCtx, task); err != nil {
+		ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
+			ID:      msgID,
+			Message: i18n.T(i18nk.BotMsgTransferErrorAddTaskFailed, map[string]any{"Error": err}),
+		})
+		return dispatcher.EndGroups
+	}
+
+	ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
+		ID: msgID,
+		Message: i18n.T(i18nk.BotMsgTransferInfoTaskAdded, map[string]any{
+			"Count":  len(elems),
+			"SizeMB": fmt.Sprintf("%.2f", float64(totalSize)/(1024*1024)),
+			"TaskID": taskID,
+		}),
+	})
+
+	return dispatcher.EndGroups
+}

client/bot/handlers/update.go

@@ -103,7 +103,7 @@ func handleUpdateCallback(ctx *ext.Context, u *ext.Update) error {
 		return err
 	}
 	ctx.EditMessage(u.GetUserChat().GetID(), &tg.MessagesEditMessageRequest{
-		ID:      u.CallbackQuery.GetMsgID(),
+		ID: u.CallbackQuery.GetMsgID(),
 		Message: i18n.T(i18nk.BotMsgUpdateInfoUpgradingWithVersion, map[string]any{
 			"Current": config.Version,
 		}),
@@ -111,7 +111,7 @@ func handleUpdateCallback(ctx *ext.Context, u *ext.Update) error {
 	latest, err := ghselfupdate.UpdateSelf(currentV, config.GitRepo)
 	if err != nil {
 		ctx.EditMessage(u.GetUserChat().GetID(), &tg.MessagesEditMessageRequest{
-			ID:      u.CallbackQuery.GetMsgID(),
+			ID: u.CallbackQuery.GetMsgID(),
 			Message: i18n.T(i18nk.BotMsgUpdateErrorUpgradeFailed, map[string]any{
 				"Error": err.Error(),
 			}),
@@ -119,7 +119,7 @@ func handleUpdateCallback(ctx *ext.Context, u *ext.Update) error {
 		return dispatcher.EndGroups
 	}
 	ctx.EditMessage(u.GetUserChat().GetID(), &tg.MessagesEditMessageRequest{
-		ID:      u.CallbackQuery.GetMsgID(),
+		ID: u.CallbackQuery.GetMsgID(),
 		Message: i18n.T(i18nk.BotMsgUpdateInfoUpgradeSuccess, map[string]any{
 			"Version": latest.Version.String(),
 		}),

client/bot/handlers/utils/msgelem/storage.go

@@ -50,8 +50,13 @@ func BuildAddSelectStorageKeyboard(stors []storage.Storage, adddata tcbdata.Add)
 
 			DirectLinks: adddata.DirectLinks,
 
-			Aria2URIs: adddata.Aria2URIs,
+			Aria2URIs:  adddata.Aria2URIs,
-			YtdlpURLs: adddata.YtdlpURLs,
+			YtdlpURLs:  adddata.YtdlpURLs,
+			YtdlpFlags: adddata.YtdlpFlags,
+
+			TransferSourceStorName: adddata.TransferSourceStorName,
+			TransferSourcePath:     adddata.TransferSourcePath,
+			TransferFiles:          adddata.TransferFiles,
 		}
 		dataid := xid.New().String()
 		err := cache.Set(dataid, data)

client/bot/handlers/utils/shortcut/aria2.go

@@ -46,7 +46,7 @@ func CreateAndAddAria2TaskWithEdit(ctx *ext.Context, stor storage.Storage, dirPa
 	logger.Infof("Aria2 download added with GID: %s", gid)
 
 	// Create task with the GID
-	task := aria2dl.NewTask(xid.New().String(), injectCtx, gid, uris, aria2Client, stor, stor.JoinStoragePath(dirPath), aria2dl.NewProgress(msgID, userID))
+	task := aria2dl.NewTask(xid.New().String(), injectCtx, gid, uris, aria2Client, stor, dirPath, aria2dl.NewProgress(msgID, userID))
 	if err := core.AddTask(injectCtx, task); err != nil {
 		logger.Errorf("Failed to add task: %s", err)
 		ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{

client/bot/handlers/utils/shortcut/directlinks.go

@@ -16,7 +16,7 @@ import (
 
 func CreateAndAddDirectTaskWithEdit(ctx *ext.Context, stor storage.Storage, dirPath string, links []string, msgID int, userID int64) error {
 	injectCtx := tgutil.ExtWithContext(ctx.Context, ctx)
-	task := directlinks.NewTask(xid.New().String(), injectCtx, links, stor, stor.JoinStoragePath(dirPath), directlinks.NewProgress(msgID, userID))
+	task := directlinks.NewTask(xid.New().String(), injectCtx, links, stor, dirPath, directlinks.NewProgress(msgID, userID))
 	if err := core.AddTask(injectCtx, task); err != nil {
 		log.FromContext(ctx).Errorf("Failed to add task: %s", err)
 		ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{

client/bot/handlers/utils/shortcut/parsed.go

@@ -18,11 +18,11 @@ import (
 
 func CreateAndAddParsedTaskWithEdit(ctx *ext.Context, stor storage.Storage, dirPath string, item *parser.Item, msgID int, userID int64) error {
 	injectCtx := tgutil.ExtWithContext(ctx.Context, ctx)
-	task := parsed.NewTask(xid.New().String(), injectCtx, stor, stor.JoinStoragePath(dirPath), item, parsed.NewProgress(msgID, userID))
+	task := parsed.NewTask(xid.New().String(), injectCtx, stor, dirPath, item, parsed.NewProgress(msgID, userID))
 	if err := core.AddTask(injectCtx, task); err != nil {
 		log.FromContext(ctx).Errorf("Failed to add task: %s", err)
 		ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
-			ID:      msgID,
+			ID: msgID,
 			Message: i18n.T(i18nk.BotMsgCommonErrorTaskAddFailed, map[string]any{
 				"Error": err.Error(),
 			}),

client/bot/handlers/utils/shortcut/tftask.go

@@ -29,7 +29,7 @@ func CreateAndAddTGFileTaskWithEdit(ctx *ext.Context, userID int64, stor storage
 	if err != nil {
 		logger.Errorf("Failed to get user by chat ID: %s", err)
 		ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
-			ID:      trackMsgID,
+			ID: trackMsgID,
 			Message: i18n.T(i18nk.BotMsgCommonErrorGetUserWithErrFailed, map[string]any{
 				"Error": err.Error(),
 			}),
@@ -49,7 +49,7 @@ func CreateAndAddTGFileTaskWithEdit(ctx *ext.Context, userID int64, stor storage
 			if err != nil {
 				logger.Errorf("Failed to get storage by user ID and name: %s", err)
 				ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
-					ID:      trackMsgID,
+					ID: trackMsgID,
 					Message: i18n.T(i18nk.BotMsgCommonErrorGetStorageFailed, map[string]any{
 						"Error": err.Error(),
 					}),
@@ -59,7 +59,7 @@ func CreateAndAddTGFileTaskWithEdit(ctx *ext.Context, userID int64, stor storage
 		}
 	}
 startCreateTask:
-	storagePath := stor.JoinStoragePath(path.Join(dirPath, file.Name()))
+	storagePath := path.Join(dirPath, file.Name())
 	injectCtx := tgutil.ExtWithContext(ctx.Context, ctx)
 	taskid := xid.New().String()
 	task, err := tftask.NewTGFileTask(taskid, injectCtx, file, stor, storagePath,
@@ -69,7 +69,7 @@ startCreateTask:
 	if err != nil {
 		logger.Errorf("create task failed: %s", err)
 		ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
-			ID:      trackMsgID,
+			ID: trackMsgID,
 			Message: i18n.T(i18nk.BotMsgCommonErrorTaskCreateFailed, map[string]any{
 				"Error": err.Error(),
 			}),
@@ -79,7 +79,7 @@ startCreateTask:
 	if err := core.AddTask(injectCtx, task); err != nil {
 		logger.Errorf("add task failed: %s", err)
 		ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
-			ID:      trackMsgID,
+			ID: trackMsgID,
 			Message: i18n.T(i18nk.BotMsgCommonErrorTaskAddFailed, map[string]any{
 				"Error": err.Error(),
 			}),
@@ -103,7 +103,7 @@ func CreateAndAddBatchTGFileTaskWithEdit(ctx *ext.Context, userID int64, stor st
 	if err != nil {
 		logger.Errorf("Failed to get user by chat ID: %s", err)
 		ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
-			ID:      trackMsgID,
+			ID: trackMsgID,
 			Message: i18n.T(i18nk.BotMsgCommonErrorGetUserWithErrFailed, map[string]any{
 				"Error": err.Error(),
 			}),
@@ -142,7 +142,7 @@ func CreateAndAddBatchTGFileTaskWithEdit(ctx *ext.Context, userID int64, stor st
 			if err != nil {
 				logger.Errorf("Failed to get storage by user ID and name: %s", err)
 				ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
-					ID:      trackMsgID,
+					ID: trackMsgID,
 					Message: i18n.T(i18nk.BotMsgCommonErrorGetStorageFailed, map[string]any{
 						"Error": err.Error(),
 					}),
@@ -151,15 +151,15 @@ func CreateAndAddBatchTGFileTaskWithEdit(ctx *ext.Context, userID int64, stor st
 			}
 		}
 		if !dirPath.NeedNewForAlbum() {
-			storPath := fileStor.JoinStoragePath(path.Join(dirPath.String(), file.Name()))
+			storPath := path.Join(dirPath.String(), file.Name())
 			elem, err := batchtfile.NewTaskElement(fileStor, storPath, file)
 			if err != nil {
 				logger.Errorf("Failed to create task element: %s", err)
 				ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
-					ID:      trackMsgID,
+					ID: trackMsgID,
-						Message: i18n.T(i18nk.BotMsgCommonErrorTaskCreateFailed, map[string]any{
+					Message: i18n.T(i18nk.BotMsgCommonErrorTaskCreateFailed, map[string]any{
-							"Error": err.Error(),
+						"Error": err.Error(),
-						}),
+					}),
 				})
 				return dispatcher.EndGroups
 			}
@@ -188,12 +188,12 @@ func CreateAndAddBatchTGFileTaskWithEdit(ctx *ext.Context, userID int64, stor st
 		albumDir := strings.TrimSuffix(path.Base(afiles[0].file.Name()), path.Ext(afiles[0].file.Name()))
 		albumStor := afiles[0].storage
 		for _, af := range afiles {
-			afstorPath := af.storage.JoinStoragePath(path.Join(dirPath, albumDir, af.file.Name()))
+			afstorPath := path.Join(dirPath, albumDir, af.file.Name())
 			elem, err := batchtfile.NewTaskElement(albumStor, afstorPath, af.file)
 			if err != nil {
 				logger.Errorf("Failed to create task element for album file: %s", err)
 				ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
-					ID:      trackMsgID,
+					ID: trackMsgID,
 					Message: i18n.T(i18nk.BotMsgCommonErrorTaskCreateFailed, map[string]any{
 						"Error": err.Error(),
 					}),
@@ -210,7 +210,7 @@ func CreateAndAddBatchTGFileTaskWithEdit(ctx *ext.Context, userID int64, stor st
 	if err := core.AddTask(injectCtx, task); err != nil {
 		logger.Errorf("Failed to add batch task: %s", err)
 		ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
-			ID:      trackMsgID,
+			ID: trackMsgID,
 			Message: i18n.T(i18nk.BotMsgCommonErrorTaskAddFailed, map[string]any{
 				"Error": err.Error(),
 			}),
@@ -218,8 +218,8 @@ func CreateAndAddBatchTGFileTaskWithEdit(ctx *ext.Context, userID int64, stor st
 		return dispatcher.EndGroups
 	}
 	ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
-		ID:          trackMsgID,
+		ID: trackMsgID,
-		Message:     i18n.T(i18nk.BotMsgCommonInfoBatchTasksAdded, map[string]any{
+		Message: i18n.T(i18nk.BotMsgCommonInfoBatchTasksAdded, map[string]any{
 			"Count": len(files),
 		}),
 		ReplyMarkup: nil,

client/bot/handlers/utils/shortcut/tphtask.go

@@ -32,14 +32,14 @@ func CreateAndAddtelegraphWithEdit(
 		tphpage.Path,
 		pics,
 		stor,
-		stor.JoinStoragePath(dirPath),
+		dirPath,
 		tphutil.DefaultClient(),
 		tphtask.NewProgress(trackMsgID, userID),
 	)
 	if err := core.AddTask(injectCtx, task); err != nil {
 		log.FromContext(ctx).Errorf("Failed to add task: %s", err)
 		ctx.EditMessage(userID, &tg.MessagesEditMessageRequest{
-			ID:      trackMsgID,
+			ID: trackMsgID,
 			Message: i18n.T(i18nk.BotMsgCommonErrorTaskAddFailed, map[string]any{
 				"Error": err.Error(),
 			}),

client/bot/handlers/utils/shortcut/ytdlp.go

@@ -15,7 +15,7 @@ import (
 	"github.com/krau/SaveAny-Bot/storage"
 )
 
-func CreateAndAddYtdlpTaskWithEdit(ctx *ext.Context, stor storage.Storage, dirPath string, urls []string, msgID int, userID int64) error {
+func CreateAndAddYtdlpTaskWithEdit(ctx *ext.Context, stor storage.Storage, dirPath string, urls []string, flags []string, msgID int, userID int64) error {
 	logger := log.FromContext(ctx)
 	injectCtx := tgutil.ExtWithContext(ctx.Context, ctx)
 
@@ -29,15 +29,16 @@ func CreateAndAddYtdlpTaskWithEdit(ctx *ext.Context, stor storage.Storage, dirPa
 		return dispatcher.EndGroups
 	}
 
-	logger.Infof("Creating yt-dlp task for %d URL(s)", len(urls))
+	logger.Infof("Creating yt-dlp task for %d URL(s) with %d flag(s)", len(urls), len(flags))
 
 	// Create yt-dlp task
 	task := ytdlp.NewTask(
 		xid.New().String(),
 		injectCtx,
 		urls,
+		flags,
 		stor,
-		stor.JoinStoragePath(dirPath),
+		dirPath,
 		ytdlp.NewProgress(msgID, userID),
 	)
 

client/bot/handlers/watch.go

@@ -309,7 +309,7 @@ func listenMediaMessageEvent(ch chan userclient.MediaMessageEvent) {
 				}
 			}
 		startCreateTask:
-			storagePath := stor.JoinStoragePath(path.Join(dirPath, file.Name()))
+			storagePath := path.Join(dirPath, file.Name())
 			injectCtx := tgutil.ExtWithContext(ctx.Context, ctx)
 			taskid := xid.New().String()
 			task, err := coretfile.NewTGFileTask(taskid, injectCtx, file, stor, storagePath, nil)
@@ -403,7 +403,7 @@ func processWatchMediaGroup(ctx *ext.Context, user *database.User, stor storage.
 		logger.Infof("Creating album folder for group %d: %s with %d files", groupID, albumDir, len(afiles))
 
 		for _, af := range afiles {
-			afstorPath := af.storage.JoinStoragePath(path.Join(dirPath, albumDir, af.file.Name()))
+			afstorPath := path.Join(dirPath, albumDir, af.file.Name())
 			taskid := xid.New().String()
 			task, err := coretfile.NewTGFileTask(taskid, injectCtx, af.file, albumStor, afstorPath, nil)
 			if err != nil {

client/bot/handlers/ytdlp.go

@@ -7,7 +7,6 @@ import (
 	"github.com/celestix/gotgproto/dispatcher"
 	"github.com/celestix/gotgproto/ext"
 	"github.com/charmbracelet/log"
-	"github.com/duke-git/lancet/v2/slice"
 
 	"github.com/krau/SaveAny-Bot/client/bot/handlers/utils/msgelem"
 	"github.com/krau/SaveAny-Bot/common/i18n"
@@ -25,29 +24,59 @@ func handleYtdlpCmd(ctx *ext.Context, update *ext.Update) error {
 		return dispatcher.EndGroups
 	}
 
-	urls := args[1:]
+	// Separate URLs and flags from arguments
-	// Validate and clean URLs
+	var urls []string
-	for i, link := range urls {
+	var flags []string
-		urls[i] = strings.TrimSpace(link)
+
-		u, err := url.Parse(link)
+	for i := 1; i < len(args); i++ {
-		if err != nil || u.Scheme == "" || u.Host == "" {
+		arg := strings.TrimSpace(args[i])
-			logger.Warnf("Invalid URL: %s", link)
+		if arg == "" {
-			urls[i] = ""
+			continue
+		}
+
+		// Check if it's a flag (starts with - or --)
+		if strings.HasPrefix(arg, "-") {
+			flags = append(flags, arg)
+			// Check if the next argument might be a value for this flag
+			// Don't consume it if it starts with - or looks like a URL with scheme
+			if i+1 < len(args) {
+				nextArg := strings.TrimSpace(args[i+1])
+				if nextArg != "" && !strings.HasPrefix(nextArg, "-") {
+					// Check if it's clearly a URL (has ://)
+					// This handles common video URLs (http://, https://)
+					// For other yt-dlp inputs, users should ensure proper formatting
+					if strings.Contains(nextArg, "://") {
+						// It's a URL, don't consume it as a flag value
+						continue
+					}
+					// Otherwise, treat it as a flag value
+					flags = append(flags, nextArg)
+					i++ // Skip the next argument as it's been consumed
+				}
+			}
+		} else {
+			// Try to parse as URL
+			u, err := url.Parse(arg)
+			if err != nil || u.Scheme == "" || u.Host == "" {
+				logger.Warnf("Invalid URL: %s", arg)
+				continue
+			}
+			urls = append(urls, arg)
 		}
 	}
-	urls = slice.Compact(urls)
 
 	if len(urls) == 0 {
 		ctx.Reply(update, ext.ReplyTextString(i18n.T(i18nk.BotMsgYtdlpErrorNoValidUrls)), nil)
 		return dispatcher.EndGroups
 	}
 
-	logger.Debugf("Preparing yt-dlp download for %d URL(s)", len(urls))
+	logger.Debugf("Preparing yt-dlp download for %d URL(s) with %d flag(s)", len(urls), len(flags))
 
 	// Build storage selection keyboard
 	markup, err := msgelem.BuildAddSelectStorageKeyboard(storage.GetUserStorages(ctx, update.GetUserChat().GetID()), tcbdata.Add{
-		TaskType:  tasktype.TaskTypeYtdlp,
+		TaskType:   tasktype.TaskTypeYtdlp,
-		YtdlpURLs: urls,
+		YtdlpURLs:  urls,
+		YtdlpFlags: flags,
 	})
 	if err != nil {
 		return err

client/bot/handlers/ytdlp_test.go

@@ -0,0 +1,129 @@
+package handlers
+
+import (
+	"net/url"
+	"strings"
+	"testing"
+)
+
+// TestYtdlpArgumentParsing tests the URL and flag separation logic
+func TestYtdlpArgumentParsing(t *testing.T) {
+	tests := []struct {
+		name          string
+		input         string
+		expectedURLs  []string
+		expectedFlags []string
+	}{
+		{
+			name:          "Single URL without flags",
+			input:         "/ytdlp https://example.com/video",
+			expectedURLs:  []string{"https://example.com/video"},
+			expectedFlags: []string{},
+		},
+		{
+			name:          "Multiple URLs without flags",
+			input:         "/ytdlp https://example.com/v1 https://example.com/v2",
+			expectedURLs:  []string{"https://example.com/v1", "https://example.com/v2"},
+			expectedFlags: []string{},
+		},
+		{
+			name:          "URL with format flag",
+			input:         "/ytdlp --format best https://example.com/video",
+			expectedURLs:  []string{"https://example.com/video"},
+			expectedFlags: []string{"--format", "best"},
+		},
+		{
+			name:          "URL with extract-audio flag",
+			input:         "/ytdlp --extract-audio --audio-format mp3 https://example.com/video",
+			expectedURLs:  []string{"https://example.com/video"},
+			expectedFlags: []string{"--extract-audio", "--audio-format", "mp3"},
+		},
+		{
+			name:          "Multiple URLs with flags",
+			input:         "/ytdlp --format best https://example.com/v1 https://example.com/v2",
+			expectedURLs:  []string{"https://example.com/v1", "https://example.com/v2"},
+			expectedFlags: []string{"--format", "best"},
+		},
+		{
+			name:          "Flags mixed with URLs",
+			input:         "/ytdlp https://example.com/v1 --format best https://example.com/v2",
+			expectedURLs:  []string{"https://example.com/v1", "https://example.com/v2"},
+			expectedFlags: []string{"--format", "best"},
+		},
+		{
+			name:          "Short flag",
+			input:         "/ytdlp -f best https://example.com/video",
+			expectedURLs:  []string{"https://example.com/video"},
+			expectedFlags: []string{"-f", "best"},
+		},
+		{
+			name:          "Boolean flag",
+			input:         "/ytdlp --extract-audio https://example.com/video",
+			expectedURLs:  []string{"https://example.com/video"},
+			expectedFlags: []string{"--extract-audio"},
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			args := strings.Split(tt.input, " ")
+
+			// Simulate the parsing logic from handleYtdlpCmd
+			var urls []string
+			var flags []string
+
+			for i := 1; i < len(args); i++ {
+				arg := strings.TrimSpace(args[i])
+				if arg == "" {
+					continue
+				}
+
+				// Check if it's a flag (starts with - or --)
+				if strings.HasPrefix(arg, "-") {
+					flags = append(flags, arg)
+					// Check if the next argument might be a value for this flag
+					if i+1 < len(args) {
+						nextArg := strings.TrimSpace(args[i+1])
+						if nextArg != "" && !strings.HasPrefix(nextArg, "-") {
+							// Check if it's clearly a URL (has ://)
+							if strings.Contains(nextArg, "://") {
+								// It's a URL, don't consume it as a flag value
+								continue
+							}
+							// Otherwise, treat it as a flag value
+							flags = append(flags, nextArg)
+							i++ // Skip the next argument as it's been consumed
+						}
+					}
+				} else {
+					// Try to parse as URL
+					u, err := url.Parse(arg)
+					if err != nil || u.Scheme == "" || u.Host == "" {
+						continue
+					}
+					urls = append(urls, arg)
+				}
+			}
+
+			// Verify URLs
+			if len(urls) != len(tt.expectedURLs) {
+				t.Errorf("Expected %d URLs, got %d", len(tt.expectedURLs), len(urls))
+			}
+			for i, expectedURL := range tt.expectedURLs {
+				if i >= len(urls) || urls[i] != expectedURL {
+					t.Errorf("Expected URL[%d] to be '%s', got '%s'", i, expectedURL, urls[i])
+				}
+			}
+
+			// Verify flags
+			if len(flags) != len(tt.expectedFlags) {
+				t.Errorf("Expected %d flags, got %d", len(tt.expectedFlags), len(flags))
+			}
+			for i, expectedFlag := range tt.expectedFlags {
+				if i >= len(flags) || flags[i] != expectedFlag {
+					t.Errorf("Expected flag[%d] to be '%s', got '%s'", i, expectedFlag, flags[i])
+				}
+			}
+		})
+	}
+}

cmd/run.go

@@ -10,7 +10,6 @@ import (
 	"slices"
 
 	"github.com/charmbracelet/log"
-	"github.com/krau/SaveAny-Bot/api"
 	"github.com/krau/SaveAny-Bot/client/bot"
 	userclient "github.com/krau/SaveAny-Bot/client/user"
 	"github.com/krau/SaveAny-Bot/common/cache"
@@ -77,11 +76,7 @@ func initAll(ctx context.Context, cmd *cobra.Command) (<-chan struct{}, error) {
 			logger.Fatal("User login failed", "error", err)
 		}
 	}
-	exitChan := bot.Init(ctx)
+	return bot.Init(ctx), nil
-	if err := api.Init(ctx); err != nil {
-		return nil, fmt.Errorf("failed to init API server: %w", err)
-	}
-	return exitChan, nil
 }
 
 func cleanCache() {

cmd/upload/cmd.go

@@ -90,7 +90,7 @@ func Upload(cmd *cobra.Command, args []string) error {
 	fileName := fileInfo.Name()
 	fileSize := fileInfo.Size()
 
-	uploadPath := stor.JoinStoragePath(path.Join(dirPath, fileName))
+	uploadPath := path.Join(dirPath, fileName)
 
 	ctx = context.WithValue(ctx, ctxkey.ContentLength, fileSize)
 	ctx = tgutil.ExtWithContext(ctx, bot.ExtContext())

common/i18n/i18nk/keys.go

@@ -21,6 +21,7 @@ const (
 	BotMsgCmdDl                                           Key = "bot.msg.cmd.dl"
 	BotMsgCmdFnametmpl                                    Key = "bot.msg.cmd.fnametmpl"
 	BotMsgCmdHelp                                         Key = "bot.msg.cmd.help"
+	BotMsgCmdImport                                       Key = "bot.msg.cmd.import"
 	BotMsgCmdLswatch                                      Key = "bot.msg.cmd.lswatch"
 	BotMsgCmdParser                                       Key = "bot.msg.cmd.parser"
 	BotMsgCmdRule                                         Key = "bot.msg.cmd.rule"
@@ -30,6 +31,7 @@ const (
 	BotMsgCmdStorage                                      Key = "bot.msg.cmd.storage"
 	BotMsgCmdSyncpeers                                    Key = "bot.msg.cmd.syncpeers"
 	BotMsgCmdTask                                         Key = "bot.msg.cmd.task"
+	BotMsgCmdTransfer                                     Key = "bot.msg.cmd.transfer"
 	BotMsgCmdUnwatch                                      Key = "bot.msg.cmd.unwatch"
 	BotMsgCmdUpdate                                       Key = "bot.msg.cmd.update"
 	BotMsgCmdWatch                                        Key = "bot.msg.cmd.watch"
@@ -161,6 +163,20 @@ const (
 	BotMsgProgressTelegraphProgressPrefix                 Key = "bot.msg.progress.telegraph_progress_prefix"
 	BotMsgProgressTelegraphStartPrefix                    Key = "bot.msg.progress.telegraph_start_prefix"
 	BotMsgProgressTotalSizePrefix                         Key = "bot.msg.progress.total_size_prefix"
+	BotMsgProgressTransferAvgSpeedPrefix                  Key = "bot.msg.progress.transfer_avg_speed_prefix"
+	BotMsgProgressTransferElapsedTimePrefix               Key = "bot.msg.progress.transfer_elapsed_time_prefix"
+	BotMsgProgressTransferFailedFilesPrefix               Key = "bot.msg.progress.transfer_failed_files_prefix"
+	BotMsgProgressTransferFailedPrefix                    Key = "bot.msg.progress.transfer_failed_prefix"
+	BotMsgProgressTransferProcessingMore                  Key = "bot.msg.progress.transfer_processing_more"
+	BotMsgProgressTransferProcessingPrefix                Key = "bot.msg.progress.transfer_processing_prefix"
+	BotMsgProgressTransferProgressPrefix                  Key = "bot.msg.progress.transfer_progress_prefix"
+	BotMsgProgressTransferRemainingTimePrefix             Key = "bot.msg.progress.transfer_remaining_time_prefix"
+	BotMsgProgressTransferSpeedPrefix                     Key = "bot.msg.progress.transfer_speed_prefix"
+	BotMsgProgressTransferStartPrefix                     Key = "bot.msg.progress.transfer_start_prefix"
+	BotMsgProgressTransferSuccessPrefix                   Key = "bot.msg.progress.transfer_success_prefix"
+	BotMsgProgressTransferTotalFilesPrefix                Key = "bot.msg.progress.transfer_total_files_prefix"
+	BotMsgProgressTransferTotalSizePrefix                 Key = "bot.msg.progress.transfer_total_size_prefix"
+	BotMsgProgressTransferUploadedPrefix                  Key = "bot.msg.progress.transfer_uploaded_prefix"
 	BotMsgProgressYtdlpDone                               Key = "bot.msg.progress.ytdlp_done"
 	BotMsgProgressYtdlpDownloading                        Key = "bot.msg.progress.ytdlp_downloading"
 	BotMsgProgressYtdlpStart                              Key = "bot.msg.progress.ytdlp_start"
@@ -216,6 +232,22 @@ const (
 	BotMsgTelegraphInfoPicCountPrefix                     Key = "bot.msg.telegraph.info_pic_count_prefix"
 	BotMsgTelegraphInfoPromptSelectStorage                Key = "bot.msg.telegraph.info_prompt_select_storage"
 	BotMsgTelegraphInfoTitlePrefix                        Key = "bot.msg.telegraph.info_title_prefix"
+	BotMsgTransferErrorAddTaskFailed                      Key = "bot.msg.transfer.error_add_task_failed"
+	BotMsgTransferErrorBuildStorageSelectKeyboardFailed   Key = "bot.msg.transfer.error_build_storage_select_keyboard_failed"
+	BotMsgTransferErrorInvalidRegex                       Key = "bot.msg.transfer.error_invalid_regex"
+	BotMsgTransferErrorInvalidSource                      Key = "bot.msg.transfer.error_invalid_source"
+	BotMsgTransferErrorInvalidTarget                      Key = "bot.msg.transfer.error_invalid_target"
+	BotMsgTransferErrorListFilesFailed                    Key = "bot.msg.transfer.error_list_files_failed"
+	BotMsgTransferErrorNoFilesToTransfer                  Key = "bot.msg.transfer.error_no_files_to_transfer"
+	BotMsgTransferErrorStorageNotFound                    Key = "bot.msg.transfer.error_storage_not_found"
+	BotMsgTransferErrorStorageNotListable                 Key = "bot.msg.transfer.error_storage_not_listable"
+	BotMsgTransferErrorStorageNotReadable                 Key = "bot.msg.transfer.error_storage_not_readable"
+	BotMsgTransferErrorTargetNotFound                     Key = "bot.msg.transfer.error_target_not_found"
+	BotMsgTransferInfoFetchingFiles                       Key = "bot.msg.transfer.info_fetching_files"
+	BotMsgTransferInfoFilesSelectStorage                  Key = "bot.msg.transfer.info_files_select_storage"
+	BotMsgTransferInfoTaskAdded                           Key = "bot.msg.transfer.info_task_added"
+	BotMsgTransferStartStats                              Key = "bot.msg.transfer.start_stats"
+	BotMsgTransferUsage                                   Key = "bot.msg.transfer.usage"
 	BotMsgUpdateButtonUpgrade                             Key = "bot.msg.update.button_upgrade"
 	BotMsgUpdateErrorCheckLatestFailed                    Key = "bot.msg.update.error_check_latest_failed"
 	BotMsgUpdateErrorNoReleaseFound                       Key = "bot.msg.update.error_no_release_found"

common/i18n/locale/en.yaml

@@ -29,6 +29,7 @@ bot:
       /silent - Toggle silent mode
       /storage - Set default storage
       /save [custom filename] - Save file
+      /import <storage_name> <dir_path> [channel_id] [filter] - Import files from storage to Telegram
       /dir - Manage storage directories
       /rule - Manage rules
       /config - Modify configuration
@@ -52,6 +53,8 @@ bot:
       dl: "Download files from given links"
       aria2dl: "Download files using Aria2"
       ytdlp: "Download video/audio using yt-dlp"
+      import: "Import files from storage to Telegram"
+      transfer: "Transfer files between storages"
       task: "Manage task queue"
       cancel: "Cancel task"
       watch: "Watch chats (UserBot)"
@@ -289,11 +292,33 @@ bot:
       error_no_valid_links: "No valid links to download"
       info_files_select_storage: "Total {{.Count}} files, please select storage"
     ytdlp:
-      usage: "Usage: /ytdlp <URL1> <URL2> ..."
+      usage: "Usage: /ytdlp [OPTIONS] <URL1> [URL2] ...\nExamples:\n  /ytdlp https://example.com/video\n  /ytdlp --format best https://example.com/video\n  /ytdlp --extract-audio --audio-format mp3 https://example.com/video"
       error_no_valid_urls: "No valid URLs"
       info_urls_select_storage: "Found {{.Count}} links, please select storage"
       info_downloading: "Downloading via yt-dlp..."
       error_download_failed: "yt-dlp download failed: {{.Error}}"
+    transfer:
+      usage: |
+        Usage: /transfer <source_storage>:/<source_path> [filter]
+        Examples:
+        /transfer local1:/downloads
+        /transfer alist1:/media/photos
+        /transfer webdav1:/files ".*\.mp4$"
+      error_invalid_source: "Invalid source path format, should be: storage_name:/path"
+      error_invalid_target: "Invalid target path format, should be: storage_name:/path"
+      error_storage_not_found: "Storage '{{.StorageName}}' not found or access denied: {{.Error}}"
+      error_storage_not_listable: "Storage '{{.StorageName}}' does not support listing files"
+      error_storage_not_readable: "Storage '{{.StorageName}}' does not support reading files"
+      error_target_not_found: "Target storage '{{.StorageName}}' not found or access denied: {{.Error}}"
+      info_fetching_files: "Fetching file list..."
+      error_list_files_failed: "Failed to list files: {{.Error}}"
+      error_invalid_regex: "Invalid regular expression: {{.Error}}"
+      error_no_files_to_transfer: "No files to transfer in directory"
+      error_add_task_failed: "Failed to add task: {{.Error}}"
+      info_task_added: "Added {{.Count}} files to transfer queue\nTotal size: {{.SizeMB}} MB\nTask ID: {{.TaskID}}"
+      start_stats: "Total files: {{.Count}}\nTotal size: {{.SizeMB}} MB"
+      info_files_select_storage: "Total {{.Count}} files ({{.SizeMB}} MB), please select target storage"
+      error_build_storage_select_keyboard_failed: "Failed to build storage selection keyboard: {{.Error}}"
     cancel:
       usage: "Usage: /cancel <task_id>"
       error_cancel_failed: "Failed to cancel task: {{.Error}}"
@@ -342,6 +367,20 @@ bot:
       ytdlp_done: "yt-dlp download completed and transferred ({{.Count}} files)\n"
       downloaded_prefix: "\nDownloaded: "
       current_speed_prefix: "\nCurrent speed: "
+      transfer_start_prefix: "Transfering: "
+      transfer_progress_prefix: "Transfer progress: "
+      transfer_uploaded_prefix: "\nUploaded: "
+      transfer_speed_prefix: "\nSpeed: "
+      transfer_remaining_time_prefix: "\nRemaining time: "
+      transfer_processing_prefix: "\nProcessing:\n"
+      transfer_processing_more: "...and {{.Count}} more files\n"
+      transfer_failed_prefix: "Transfer failed\n"
+      transfer_success_prefix: "Transfer completed\n"
+      transfer_total_files_prefix: "\nTotal files: "
+      transfer_total_size_prefix: "\nTotal size: "
+      transfer_elapsed_time_prefix: "\nElapsed time: "
+      transfer_avg_speed_prefix: "\nAverage speed: "
+      transfer_failed_files_prefix: "\nFailed files: "
     syncpeers:
       start: "Starting to sync peers..."
       done: "Peer sync completed, total {{.Count}} chats synced"

common/i18n/locale/zh-Hans.yaml

@@ -30,6 +30,7 @@ bot:
       /storage - 设置默认存储位置
       /save [自定义文件名] - 保存文件
       /dl <链接1> <链接2> ... - 下载给定链接的文件
+      /import <存储名> <目录路径> [频道ID] [过滤器] - 从存储端导入文件到 Telegram
       /dir - 管理存储目录
       /rule - 管理规则
       /config - 修改配置
@@ -53,6 +54,8 @@ bot:
       dl: "下载给定链接的文件"
       aria2dl: "使用 Aria2 下载给定链接的文件"
       ytdlp: "使用 yt-dlp 下载视频/音频"
+      import: "从存储端导入文件到 Telegram"
+      transfer: "在存储端之间传输文件"
       task: "管理任务队列"
       cancel: "取消任务"
       watch: "监听聊天(UserBot)"
@@ -290,11 +293,33 @@ bot:
       error_no_valid_links: "没有有效的链接可供下载"
       info_files_select_storage: "共 {{.Count}} 个文件, 请选择存储位置"
     ytdlp:
-      usage: "用法: /ytdlp <URL1> <URL2> ..."
+      usage: "用法: /ytdlp [选项] <URL1> [URL2] ...\n示例:\n  /ytdlp https://example.com/video\n  /ytdlp --format best https://example.com/video\n  /ytdlp --extract-audio --audio-format mp3 https://example.com/video"
       error_no_valid_urls: "没有有效的 URL"
       info_urls_select_storage: "共 {{.Count}} 个链接, 请选择存储位置"
       info_downloading: "正在通过 yt-dlp 下载..."
       error_download_failed: "yt-dlp 下载失败: {{.Error}}"
+    transfer:
+      usage: |
+        用法: /transfer <source_storage>:/<source_path> [filter]
+        示例:
+        /transfer local1:/downloads
+        /transfer alist1:/media/photos
+        /transfer webdav1:/files ".*\.mp4$"
+      error_invalid_source: "源路径格式无效，应为: storage_name:/path"
+      error_invalid_target: "目标路径格式无效，应为: storage_name:/path"
+      error_storage_not_found: "存储端 '{{.StorageName}}' 不存在或您无权访问: {{.Error}}"
+      error_storage_not_listable: "存储端 '{{.StorageName}}' 不支持列举文件功能"
+      error_storage_not_readable: "存储端 '{{.StorageName}}' 不支持读取文件功能"
+      error_target_not_found: "目标存储端 '{{.StorageName}}' 不存在或您无权访问: {{.Error}}"
+      info_fetching_files: "正在获取文件列表..."
+      error_list_files_failed: "获取文件列表失败: {{.Error}}"
+      error_invalid_regex: "正则表达式无效: {{.Error}}"
+      error_no_files_to_transfer: "目录中没有可传输的文件"
+      error_add_task_failed: "添加任务失败: {{.Error}}"
+      info_task_added: "已添加 {{.Count}} 个文件到传输队列\n总大小: {{.SizeMB}} MB\n任务 ID: {{.TaskID}}"
+      start_stats: "总文件数: {{.Count}}\n总大小: {{.SizeMB}} MB"
+      info_files_select_storage: "共 {{.Count}} 个文件 (总大小: {{.SizeMB}} MB)，请选择目标存储位置"
+      error_build_storage_select_keyboard_failed: "构建存储选择键盘失败: {{.Error}}"
     cancel:
       usage: "用法: /cancel <task_id>"
       error_cancel_failed: "取消任务失败: {{.Error}}"
@@ -343,6 +368,20 @@ bot:
       ytdlp_done: "yt-dlp 下载完成并已转存 ({{.Count}} 个文件)\n"
       downloaded_prefix: "\n已下载: "
       current_speed_prefix: "\n当前速度: "
+      transfer_start_prefix: "正在转存: "
+      transfer_progress_prefix: "转存进度: "
+      transfer_uploaded_prefix: "\n已上传: "
+      transfer_speed_prefix: "\n速度: "
+      transfer_remaining_time_prefix: "\n剩余时间: "
+      transfer_processing_prefix: "\n正在处理:\n"
+      transfer_processing_more: "...和其他 {{.Count}} 个文件\n"
+      transfer_failed_prefix: "转存失败\n"
+      transfer_success_prefix: "转存完成\n"
+      transfer_total_files_prefix: "\n总文件数: "
+      transfer_total_size_prefix: "\n总大小: "
+      transfer_elapsed_time_prefix: "\n耗时: "
+      transfer_avg_speed_prefix: "\n平均速度: "
+      transfer_failed_files_prefix: "\n失败文件数: "
     syncpeers:
       start: "正在同步对话列表..."
       success: "对话列表同步完成, 共同步 {{.Count}} 个对话"

common/utils/dlutil/dl.go

@@ -1,6 +1,9 @@
 package dlutil
 
-import "time"
+import (
+	"fmt"
+	"time"
+)
 
 var threadsLevels = []struct {
 	threads int
@@ -31,3 +34,23 @@ func GetSpeed(downloaded int64, startTime time.Time) float64 {
 	}
 	return float64(downloaded) / elapsed
 }
+
+// FormatSize formats a byte size as a human-readable string
+func FormatSize(bytes int64) string {
+	const (
+		KB = 1024
+		MB = KB * 1024
+		GB = MB * 1024
+	)
+	
+	switch {
+	case bytes >= GB:
+		return fmt.Sprintf("%.2f GB", float64(bytes)/float64(GB))
+	case bytes >= MB:
+		return fmt.Sprintf("%.2f MB", float64(bytes)/float64(MB))
+	case bytes >= KB:
+		return fmt.Sprintf("%.2f KB", float64(bytes)/float64(KB))
+	default:
+		return fmt.Sprintf("%d B", bytes)
+	}
+}

config.example.toml

@@ -29,17 +29,6 @@ secret = ""
 # 转存完成后删除 Aria2 下载的本地文件
 remove_after_transfer = true
 
-# HTTP API 配置
-[api]
-# 启用 HTTP API 服务
-enable = false
-# API 服务监听端口
-port = 8080
-# API 访问令牌 (留空则不验证)
-token = ""
-# 任务完成回调 Webhook URL (留空则不回调)
-webhook_url = ""
-
 # 存储列表
 [[storages]]
 # 标识名, 需要唯一

config/viper.go

@@ -33,7 +33,6 @@ type Config struct {
 	Storages []storage.StorageConfig `toml:"-" mapstructure:"-" json:"storages"`
 	Parser   parserConfig            `toml:"parser" mapstructure:"parser" json:"parser"`
 	Hook     hookConfig              `toml:"hook" mapstructure:"hook" json:"hook"`
-	API      apiConfig               `toml:"api" mapstructure:"api" json:"api"`
 }
 
 type aria2Config struct {
@@ -43,13 +42,6 @@ type aria2Config struct {
 	KeepFile bool   `toml:"keep_file" mapstructure:"keep_file" json:"keep_file"`
 }
 
-type apiConfig struct {
-	Enable     bool   `toml:"enable" mapstructure:"enable" json:"enable"`
-	Port       int    `toml:"port" mapstructure:"port" json:"port"`
-	Token      string `toml:"token" mapstructure:"token" json:"token"`
-	WebhookURL string `toml:"webhook_url" mapstructure:"webhook_url" json:"webhook_url"`
-}
-
 var cfg = &Config{}
 
 func C() Config {
@@ -123,12 +115,6 @@ func Init(ctx context.Context, configFile ...string) error {
 		// 数据库
 		"db.path":    "data/saveany.db",
 		"db.session": "data/session.db",
-
-		// API
-		"api.enable":      false,
-		"api.port":        8080,
-		"api.token":       "",
-		"api.webhook_url": "",
 	}
 
 	for key, value := range defaultConfigs {

core/tasks/directlinks/execute.go

@@ -45,10 +45,17 @@ func (t *Task) Execute(ctx context.Context) error {
 			fetchedTotalBytes.Add(resp.ContentLength)
 			file.Size = resp.ContentLength
 			if name := resp.Header.Get("Content-Disposition"); name != "" {
-				// Set file name
+				// Set file name from Content-Disposition header
 				filename := parseFilename(name)
 				file.Name = filename
 			}
+			// Fallback: extract filename from URL if no filename was determined from Content-Disposition
+			if file.Name == "" {
+				file.Name = filenameFromURL(file.URL)
+			}
+			if file.Name == "" {
+				return fmt.Errorf("could not determine filename for %s", file.URL)
+			}
 
 			return nil
 		})

core/tasks/directlinks/util.go

@@ -173,6 +173,35 @@ func parseFilenameFallback(cd string) string {
 	return decodeFilenameParam(value)
 }
 
+// filenameFromURL extracts filename from a URL path.
+// It uses the last path segment and removes any query parameters.
+// Returns empty string if the URL cannot be parsed or has no valid path.
+func filenameFromURL(rawURL string) string {
+	u, err := url.Parse(rawURL)
+	if err != nil {
+		return ""
+	}
+
+	// Get the path and extract the base name
+	path := u.Path
+	if path == "" || path == "/" {
+		return ""
+	}
+
+	// Find the last path segment
+	idx := strings.LastIndex(path, "/")
+	if idx >= 0 && idx < len(path)-1 {
+		filename := path[idx+1:]
+		// URL decode the filename
+		if decoded, err := url.QueryUnescape(filename); err == nil {
+			return decoded
+		}
+		return filename
+	}
+
+	return ""
+}
+
 var progressUpdatesLevels = []struct {
 	size        int64 // 文件大小阈值
 	stepPercent int   // 每多少 % 更新一次

core/tasks/directlinks/util_test.go

@@ -0,0 +1,83 @@
+package directlinks
+
+import (
+	"testing"
+)
+
+func TestFilenameFromURL(t *testing.T) {
+	tests := []struct {
+		name     string
+		url      string
+		expected string
+	}{
+		{
+			name:     "simple file",
+			url:      "https://example.com/file.zip",
+			expected: "file.zip",
+		},
+		{
+			name:     "file with path",
+			url:      "https://example.com/path/to/document.pdf",
+			expected: "document.pdf",
+		},
+		{
+			name:     "url with query params",
+			url:      "https://example.com/file.mp4?token=abc123",
+			expected: "file.mp4",
+		},
+		{
+			name:     "url with fragment",
+			url:      "https://example.com/file.txt#section",
+			expected: "file.txt",
+		},
+		{
+			name:     "url encoded filename",
+			url:      "https://example.com/%E6%B5%8B%E8%AF%95.zip",
+			expected: "测试.zip",
+		},
+		{
+			name:     "url encoded Chinese filename",
+			url:      "https://example.com/10%E6%9C%8817%E6%97%A5(6).mp4",
+			expected: "10月17日(6).mp4",
+		},
+		{
+			name:     "root path only",
+			url:      "https://example.com/",
+			expected: "",
+		},
+		{
+			name:     "no path",
+			url:      "https://example.com",
+			expected: "",
+		},
+		{
+			name:     "empty url",
+			url:      "",
+			expected: "",
+		},
+		{
+			name:     "file with spaces encoded",
+			url:      "https://example.com/my%20file.txt",
+			expected: "my file.txt",
+		},
+		{
+			name:     "complex path with multiple slashes",
+			url:      "https://cdn.example.com/a/b/c/d/e/video.mkv",
+			expected: "video.mkv",
+		},
+		{
+			name:     "malformed url with invalid characters",
+			url:      "://invalid url",
+			expected: "",
+		},
+	}
+
+	for _, tt := range tests {
+		t.Run(tt.name, func(t *testing.T) {
+			result := filenameFromURL(tt.url)
+			if result != tt.expected {
+				t.Errorf("filenameFromURL(%q) = %q, expected %q", tt.url, result, tt.expected)
+			}
+		})
+	}
+}

core/tasks/transfer/execute.go

@@ -0,0 +1,142 @@
+package transfer
+
+import (
+	"context"
+	"fmt"
+	"io"
+	"os"
+	"path"
+	"path/filepath"
+
+	"github.com/charmbracelet/log"
+	"github.com/krau/SaveAny-Bot/config"
+	"github.com/krau/SaveAny-Bot/pkg/enums/ctxkey"
+	"github.com/krau/SaveAny-Bot/storage"
+	"golang.org/x/sync/errgroup"
+)
+
+// Execute implements core.Executable.
+func (t *Task) Execute(ctx context.Context) error {
+	logger := log.FromContext(ctx).WithPrefix(fmt.Sprintf("transfer[%s]", t.ID))
+	logger.Info("Starting transfer task")
+	t.Progress.OnStart(ctx, t)
+
+	workers := config.C().Workers
+	eg, gctx := errgroup.WithContext(ctx)
+	eg.SetLimit(workers)
+
+	for _, elem := range t.elems {
+		eg.Go(func() error {
+			t.processingMu.RLock()
+			if t.processing[elem.ID] != nil {
+				t.processingMu.RUnlock()
+				return fmt.Errorf("element with ID %s is already being processed", elem.ID)
+			}
+			t.processingMu.RUnlock()
+
+			t.processingMu.Lock()
+			t.processing[elem.ID] = &elem
+			t.processingMu.Unlock()
+
+			defer func() {
+				t.processingMu.Lock()
+				delete(t.processing, elem.ID)
+				t.processingMu.Unlock()
+			}()
+
+			err := t.processElement(gctx, elem)
+			if err != nil && !t.IgnoreErrors {
+				return err
+			}
+			if err != nil {
+				t.processingMu.Lock()
+				t.failed[elem.ID] = err
+				t.processingMu.Unlock()
+				logger.Errorf("Failed to process file %s: %v", elem.FileInfo.Name, err)
+			}
+			return nil
+		})
+	}
+
+	err := eg.Wait()
+	if err != nil {
+		logger.Errorf("Error during transfer processing: %v", err)
+	} else {
+		logger.Info("Transfer task completed successfully")
+	}
+
+	t.Progress.OnDone(ctx, t, err)
+	return err
+}
+
+func (t *Task) processElement(ctx context.Context, elem TaskElement) error {
+	logger := log.FromContext(ctx).WithPrefix(fmt.Sprintf("file[%s]", elem.FileInfo.Name))
+
+	// Check whether the source storage supports reading
+	readableStorage, ok := elem.SourceStorage.(storage.StorageReadable)
+	if !ok {
+		return fmt.Errorf("source storage %s does not support reading", elem.SourceStorage.Name())
+	}
+
+	logger.Info("Opening file from source storage")
+	reader, size, err := readableStorage.OpenFile(ctx, elem.SourcePath)
+	if err != nil {
+		return fmt.Errorf("failed to open file: %w", err)
+	}
+	defer reader.Close()
+
+	// Build target storage path: /target_path/filename
+	storagePath := path.Join(elem.TargetPath, elem.FileInfo.Name)
+
+	// Inject file size into context
+	ctx = context.WithValue(ctx, ctxkey.ContentLength, size)
+
+	if config.C().Stream {
+		if err := elem.TargetStorage.Save(ctx, reader, storagePath); err != nil {
+			return fmt.Errorf("failed to upload file to storage: %w", err)
+		}
+	} else {
+		logger.Info("Downloading to temporary file for ReadSeeker support")
+		tempFile, err := t.downloadToTemp(reader, elem.FileInfo.Name)
+		if err != nil {
+			return fmt.Errorf("failed to download to temp: %w", err)
+		}
+		defer os.Remove(tempFile.Name())
+		defer tempFile.Close()
+
+		if _, err := tempFile.Seek(0, io.SeekStart); err != nil {
+			return fmt.Errorf("failed to seek temp file: %w", err)
+		}
+
+		logger.Infof("Uploading file to storage (size: %d bytes)", size)
+		if err := elem.TargetStorage.Save(ctx, tempFile, storagePath); err != nil {
+			return fmt.Errorf("failed to upload file to storage: %w", err)
+		}
+	}
+
+	t.uploaded.Add(size)
+	t.Progress.OnProgress(ctx, t)
+
+	logger.Info("File uploaded successfully")
+	return nil
+}
+
+func (t *Task) downloadToTemp(reader io.Reader, filename string) (*os.File, error) {
+	tempDir := config.C().Temp.BasePath
+	if tempDir == "" {
+		tempDir = os.TempDir()
+	}
+
+	tempFile, err := os.CreateTemp(tempDir, filepath.Base(filename)+"-*.tmp")
+	if err != nil {
+		return nil, fmt.Errorf("failed to create temp file: %w", err)
+	}
+
+	if _, err := io.Copy(tempFile, reader); err != nil {
+		tempFile.Close()
+		os.Remove(tempFile.Name())
+		return nil, fmt.Errorf("failed to copy to temp file: %w", err)
+	}
+
+	return tempFile, nil
+}

core/tasks/transfer/progress.go

@@ -0,0 +1,247 @@
+package transfer
+
+import (
+	"context"
+	"fmt"
+	"strings"
+	"sync/atomic"
+	"time"
+
+	"github.com/charmbracelet/log"
+	"github.com/gotd/td/telegram/message/entity"
+	"github.com/gotd/td/telegram/message/styling"
+	"github.com/gotd/td/tg"
+	"github.com/krau/SaveAny-Bot/common/i18n"
+	"github.com/krau/SaveAny-Bot/common/i18n/i18nk"
+	"github.com/krau/SaveAny-Bot/common/utils/dlutil"
+	"github.com/krau/SaveAny-Bot/common/utils/tgutil"
+)
+
+type ProgressTracker interface {
+	OnStart(ctx context.Context, info TaskInfo)
+	OnProgress(ctx context.Context, info TaskInfo)
+	OnDone(ctx context.Context, info TaskInfo, err error)
+}
+
+type Progress struct {
+	MessageID         int
+	ChatID            int64
+	start             time.Time
+	lastUpdatePercent atomic.Int32
+}
+
+func NewProgressTracker(messageID int, chatID int64) ProgressTracker {
+	return &Progress{
+		MessageID: messageID,
+		ChatID:    chatID,
+	}
+}
+
+func (p *Progress) OnStart(ctx context.Context, info TaskInfo) {
+	p.start = time.Now()
+	p.lastUpdatePercent.Store(0)
+	log.FromContext(ctx).Debugf("Transfer task progress tracking started for message %d in chat %d", p.MessageID, p.ChatID)
+
+	sizeMB := float64(info.TotalSize()) / (1024 * 1024)
+	statsText := i18n.T(i18nk.BotMsgTransferStartStats, map[string]any{
+		"SizeMB": fmt.Sprintf("%.2f", sizeMB),
+		"Count":  info.Count(),
+	})
+
+	entityBuilder := entity.Builder{}
+	if err := styling.Perform(&entityBuilder,
+		styling.Plain(i18n.T(i18nk.BotMsgProgressTransferStartPrefix, nil)),
+		styling.Code(statsText),
+	); err != nil {
+		log.FromContext(ctx).Errorf("Failed to build entities: %s", err)
+		return
+	}
+
+	text, entities := entityBuilder.Complete()
+	req := &tg.MessagesEditMessageRequest{
+		ID: p.MessageID,
+	}
+	req.SetMessage(text)
+	req.SetEntities(entities)
+	req.SetReplyMarkup(&tg.ReplyInlineMarkup{
+		Rows: []tg.KeyboardButtonRow{
+			{
+				Buttons: []tg.KeyboardButtonClass{
+					tgutil.BuildCancelButton(info.TaskID()),
+				},
+			},
+		},
+	})
+
+	ext := tgutil.ExtFromContext(ctx)
+	if ext != nil {
+		_, err := ext.EditMessage(p.ChatID, req)
+		if err != nil {
+			log.FromContext(ctx).Errorf("Failed to send progress start message: %s", err)
+		}
+	}
+}
+
+func (p *Progress) OnProgress(ctx context.Context, info TaskInfo) {
+	if !shouldUpdateProgress(info.TotalSize(), info.Uploaded(), int(p.lastUpdatePercent.Load())) {
+		return
+	}
+	percent := int((info.Uploaded() * 100) / info.TotalSize())
+	if p.lastUpdatePercent.Load() == int32(percent) {
+		return
+	}
+	p.lastUpdatePercent.Store(int32(percent))
+
+	log.FromContext(ctx).Debugf("Progress update: %s, %d/%d", info.TaskID(), info.Uploaded(), info.TotalSize())
+
+	entityBuilder := entity.Builder{}
+	var progressText strings.Builder
+
+	progressText.WriteString(i18n.T(i18nk.BotMsgProgressTransferProgressPrefix, nil))
+	fmt.Fprintf(&progressText, "%d%%", percent)
+	progressText.WriteString(i18n.T(i18nk.BotMsgProgressTransferUploadedPrefix, nil))
+	fmt.Fprintf(&progressText, "%.2f MB / %.2f MB",
+		float64(info.Uploaded())/(1024*1024),
+		float64(info.TotalSize())/(1024*1024))
+
+	if p.start.Unix() > 0 {
+		elapsed := time.Since(p.start)
+		speed := float64(info.Uploaded()) / elapsed.Seconds()
+		progressText.WriteString(i18n.T(i18nk.BotMsgProgressTransferSpeedPrefix, nil))
+		progressText.WriteString(dlutil.FormatSize(int64(speed)) + "/s")
+
+		if info.Uploaded() > 0 {
+			remaining := time.Duration(float64(info.TotalSize()-info.Uploaded()) / speed * float64(time.Second))
+			progressText.WriteString(i18n.T(i18nk.BotMsgProgressTransferRemainingTimePrefix, nil))
+			progressText.WriteString(formatDuration(remaining))
+		}
+	}
+
+	processing := info.Processing()
+	if len(processing) > 0 {
+		progressText.WriteString(i18n.T(i18nk.BotMsgProgressTransferProcessingPrefix, nil))
+		for i, elem := range processing {
+			if i >= 3 {
+				progressText.WriteString(i18n.T(i18nk.BotMsgProgressTransferProcessingMore, map[string]any{"Count": len(processing) - 3}))
+				break
+			}
+			fmt.Fprintf(&progressText, "- %s\n", elem.FileName())
+		}
+	}
+
+	if err := styling.Perform(&entityBuilder,
+		styling.Plain(progressText.String()),
+	); err != nil {
+		log.FromContext(ctx).Errorf("Failed to build entities: %s", err)
+		return
+	}
+
+	text, entities := entityBuilder.Complete()
+	req := &tg.MessagesEditMessageRequest{
+		ID: p.MessageID,
+	}
+	req.SetMessage(text)
+	req.SetEntities(entities)
+	req.SetReplyMarkup(&tg.ReplyInlineMarkup{
+		Rows: []tg.KeyboardButtonRow{
+			{
+				Buttons: []tg.KeyboardButtonClass{
+					tgutil.BuildCancelButton(info.TaskID()),
+				},
+			},
+		},
+	})
+
+	ext := tgutil.ExtFromContext(ctx)
+	if ext != nil {
+		ext.EditMessage(p.ChatID, req)
+	}
+}
+
+func (p *Progress) OnDone(ctx context.Context, info TaskInfo, err error) {
+	log.FromContext(ctx).Debugf("Transfer task progress tracking done for message %d in chat %d", p.MessageID, p.ChatID)
+
+	entityBuilder := entity.Builder{}
+	var resultText strings.Builder
+
+	if err != nil {
+		resultText.WriteString(i18n.T(i18nk.BotMsgProgressTransferFailedPrefix, nil))
+		resultText.WriteString(i18n.T(i18nk.BotMsgProgressErrorPrefix, nil))
+		fmt.Fprintf(&resultText, "%v\n", err)
+	} else {
+		resultText.WriteString(i18n.T(i18nk.BotMsgProgressTransferSuccessPrefix, nil))
+	}
+
+	elapsed := time.Since(p.start)
+	resultText.WriteString(i18n.T(i18nk.BotMsgProgressTransferTotalFilesPrefix, nil))
+	fmt.Fprintf(&resultText, "%d\n", info.Count())
+	resultText.WriteString(i18n.T(i18nk.BotMsgProgressTransferTotalSizePrefix, nil))
+	fmt.Fprintf(&resultText, "%.2f MB\n", float64(info.TotalSize())/(1024*1024))
+	resultText.WriteString(i18n.T(i18nk.BotMsgProgressTransferUploadedPrefix, nil))
+	fmt.Fprintf(&resultText, "%.2f MB\n", float64(info.Uploaded())/(1024*1024))
+	resultText.WriteString(i18n.T(i18nk.BotMsgProgressTransferElapsedTimePrefix, nil))
+	fmt.Fprintf(&resultText, "%s\n", formatDuration(elapsed))
+
+	if elapsed.Seconds() > 0 {
+		avgSpeed := float64(info.Uploaded()) / elapsed.Seconds()
+		resultText.WriteString(i18n.T(i18nk.BotMsgProgressTransferAvgSpeedPrefix, nil))
+		fmt.Fprintf(&resultText, "%s/s\n", dlutil.FormatSize(int64(avgSpeed)))
+	}
+
+	failedFiles := info.FailedFiles()
+	if len(failedFiles) > 0 {
+		resultText.WriteString(i18n.T(i18nk.BotMsgProgressTransferFailedFilesPrefix, nil))
+		fmt.Fprintf(&resultText, "%d\n", len(failedFiles))
+		for i, name := range failedFiles {
+			if i >= 5 {
+				resultText.WriteString(i18n.T(i18nk.BotMsgProgressTransferProcessingMore, map[string]any{"Count": len(failedFiles) - 5}))
+				break
+			}
+			fmt.Fprintf(&resultText, "- %s\n", name)
+		}
+	}
+
+	if err := styling.Perform(&entityBuilder,
+		styling.Plain(resultText.String()),
+	); err != nil {
+		log.FromContext(ctx).Errorf("Failed to build entities: %s", err)
+		return
+	}
+
+	text, entities := entityBuilder.Complete()
+	req := &tg.MessagesEditMessageRequest{
+		ID: p.MessageID,
+	}
+	req.SetMessage(text)
+	req.SetEntities(entities)
+
+	ext := tgutil.ExtFromContext(ctx)
+	if ext != nil {
+		ext.EditMessage(p.ChatID, req)
+	}
+}
+
+func shouldUpdateProgress(total, current int64, lastPercent int) bool {
+	if total == 0 {
+		return false
+	}
+	currentPercent := int((current * 100) / total)
+	return currentPercent > lastPercent && currentPercent%5 == 0
+}
+
+func formatDuration(d time.Duration) string {
+	d = d.Round(time.Second)
+	h := d / time.Hour
+	d -= h * time.Hour
+	m := d / time.Minute
+	d -= m * time.Minute
+	s := d / time.Second
+
+	if h > 0 {
+		return fmt.Sprintf("%dh%dm%ds", h, m, s)
+	}
+	if m > 0 {
+		return fmt.Sprintf("%dm%ds", m, s)
+	}
+	return fmt.Sprintf("%ds", s)
+}

core/tasks/transfer/task.go

@@ -0,0 +1,97 @@
+package transfer
+
+import (
+	"context"
+	"fmt"
+	"sync"
+	"sync/atomic"
+
+	"github.com/krau/SaveAny-Bot/core"
+	"github.com/krau/SaveAny-Bot/pkg/enums/tasktype"
+	"github.com/krau/SaveAny-Bot/pkg/storagetypes"
+	"github.com/krau/SaveAny-Bot/storage"
+	"github.com/rs/xid"
+)
+
+var _ core.Executable = (*Task)(nil)
+
+type TaskElement struct {
+	ID            string
+	SourceStorage storage.Storage
+	SourcePath    string
+	FileInfo      storagetypes.FileInfo
+	TargetStorage storage.Storage
+	TargetPath    string
+}
+
+type Task struct {
+	ID           string
+	ctx          context.Context
+	elems        []TaskElement
+	Progress     ProgressTracker
+	IgnoreErrors bool
+	uploaded     atomic.Int64
+	totalSize    int64
+	processing   map[string]TaskElementInfo
+	processingMu sync.RWMutex
+	failed       map[string]error
+}
+
+// Title implements core.Executable.
+func (t *Task) Title() string {
+	return fmt.Sprintf("[%s](%d files/%.2fMB)", t.Type(), len(t.elems), float64(t.totalSize)/(1024*1024))
+}
+
+// Type implements core.Executable.
+func (t *Task) Type() tasktype.TaskType {
+	return tasktype.TaskTypeTransfer
+}
+
+// TaskID implements core.Executable.
+func (t *Task) TaskID() string {
+	return t.ID
+}
+
+func NewTaskElement(
+	sourceStorage storage.Storage,
+	fileInfo storagetypes.FileInfo,
+	targetStorage storage.Storage,
+	targetPath string,
+) *TaskElement {
+	id := xid.New().String()
+	return &TaskElement{
+		ID:            id,
+		SourceStorage: sourceStorage,
+		SourcePath:    fileInfo.Path,
+		FileInfo:      fileInfo,
+		TargetStorage: targetStorage,
+		TargetPath:    targetPath,
+	}
+}
+
+func NewTransferTask(
+	id string,
+	ctx context.Context,
+	elems []TaskElement,
+	progress ProgressTracker,
+	ignoreErrors bool,
+) *Task {
+	task := &Task{
+		ID:       id,
+		ctx:      ctx,
+		elems:    elems,
+		Progress: progress,
+		uploaded: atomic.Int64{},
+		totalSize: func() int64 {
+			var total int64
+			for _, elem := range elems {
+				total += elem.FileInfo.Size
+			}
+			return total
+		}(),
+		processing:   make(map[string]TaskElementInfo),
+		IgnoreErrors: ignoreErrors,
+		failed:       make(map[string]error),
+	}
+	return task
+}

core/tasks/transfer/taskinfo.go

@@ -0,0 +1,73 @@
+package transfer
+
+type TaskElementInfo interface {
+	FileName() string
+	FileSize() int64
+	GetSourcePath() string
+	SourceStorageName() string
+}
+
+func (e *TaskElement) FileName() string {
+	return e.FileInfo.Name
+}
+
+func (e *TaskElement) FileSize() int64 {
+	return e.FileInfo.Size
+}
+
+func (e *TaskElement) GetSourcePath() string {
+	return e.SourcePath
+}
+
+func (e *TaskElement) SourceStorageName() string {
+	return e.SourceStorage.Name()
+}
+
+type TaskInfo interface {
+	TaskID() string
+	TotalSize() int64
+	Uploaded() int64
+	Count() int
+	Processing() []TaskElementInfo
+	FailedFiles() []string
+}
+
+func (t *Task) TotalSize() int64 {
+	return t.totalSize
+}
+
+func (t *Task) Uploaded() int64 {
+	return t.uploaded.Load()
+}
+
+func (t *Task) Count() int {
+	return len(t.elems)
+}
+
+func (t *Task) Processing() []TaskElementInfo {
+	t.processingMu.RLock()
+	defer t.processingMu.RUnlock()
+
+	result := make([]TaskElementInfo, 0, len(t.processing))
+	for _, elem := range t.processing {
+		result = append(result, elem)
+	}
+	return result
+}
+
+func (t *Task) FailedFiles() []string {
+	t.processingMu.RLock()
+	defer t.processingMu.RUnlock()
+
+	result := make([]string, 0, len(t.failed))
+	for id := range t.failed {
+		// Find the element by ID
+		for _, elem := range t.elems {
+			if elem.ID == id {
+				result = append(result, elem.FileInfo.Name)
+				break
+			}
+		}
+	}
+	return result
+}

core/tasks/ytdlp/execute.go

@@ -80,22 +80,34 @@ func (t *Task) Execute(ctx context.Context) error {
 func (t *Task) downloadFiles(ctx context.Context, tempDir string) ([]string, error) {
 	logger := log.FromContext(ctx)
 
-	// Configure yt-dlp command
+	// Configure yt-dlp command with essential settings
+	// Always set output path to ensure files go to temp directory
 	cmd := ytdlp.New().
-		FormatSort("res,ext:mp4:m4a").
+		Output(filepath.Join(tempDir, "%(title)s.%(ext)s"))
-		RecodeVideo("mp4").
+
-		Output(filepath.Join(tempDir, "%(title)s.%(ext)s")).
+	// If no custom flags are provided, use default behavior
-		RestrictFilenames()
+	if len(t.Flags) == 0 {
+		cmd = cmd.
+			FormatSort("res,ext:mp4:m4a").
+			RecodeVideo("mp4").
+			RestrictFilenames()
+	}
+	// Note: If custom flags are provided, users have full control over format/quality
+	// The output path is always set above to ensure downloads go to the correct directory
 
 	if t.Progress != nil {
 		t.Progress.OnProgress(ctx, t, "Downloading...")
 	}
 
-	// Execute download with URLs as arguments
+	// Execute download with URLs and custom flags
-	logger.Infof("Executing yt-dlp for %d URL(s)", len(t.URLs))
+	logger.Infof("Executing yt-dlp for %d URL(s) with %d custom flag(s)", len(t.URLs), len(t.Flags))
+
+	// Combine flags and URLs as arguments (flags first, then URLs)
+	// yt-dlp accepts: yt-dlp [OPTIONS] URL [URL...]
+	args := append(t.Flags, t.URLs...)
 
 	// Run with context for cancellation support
-	result, err := cmd.Run(ctx, t.URLs...)
+	result, err := cmd.Run(ctx, args...)
 	if err != nil {
 		// Check if context was canceled
 		if errors.Is(err, context.Canceled) {

core/tasks/ytdlp/task.go

@@ -15,6 +15,7 @@ type Task struct {
 	ID       string
 	ctx      context.Context
 	URLs     []string
+	Flags    []string
 	Storage  storage.Storage
 	StorPath string
 	Progress ProgressTracker
@@ -43,6 +44,7 @@ func NewTask(
 	id string,
 	ctx context.Context,
 	urls []string,
+	flags []string,
 	stor storage.Storage,
 	storPath string,
 	progressTracker ProgressTracker,
@@ -51,6 +53,7 @@ func NewTask(
 		ID:       id,
 		ctx:      ctx,
 		URLs:     urls,
+		Flags:    flags,
 		Storage:  stor,
 		StorPath: storPath,
 		Progress: progressTracker,

core/tasks/ytdlp/task_test.go

@@ -0,0 +1,114 @@
+package ytdlp
+
+import (
+	"context"
+	"io"
+	"testing"
+
+	storcfg "github.com/krau/SaveAny-Bot/config/storage"
+	storenum "github.com/krau/SaveAny-Bot/pkg/enums/storage"
+)
+
+// MockStorage is a simple mock for testing
+type MockStorage struct{}
+
+func (m *MockStorage) Init(ctx context.Context, cfg storcfg.StorageConfig) error     { return nil }
+func (m *MockStorage) Type() storenum.StorageType                                    { return "mock" }
+func (m *MockStorage) Name() string                                                  { return "test-storage" }
+func (m *MockStorage) JoinStoragePath(p string) string                               { return "test-path" }
+func (m *MockStorage) Save(ctx context.Context, reader io.Reader, path string) error { return nil }
+func (m *MockStorage) Exists(ctx context.Context, path string) bool                  { return false }
+
+func TestNewTask(t *testing.T) {
+	ctx := context.Background()
+	urls := []string{"https://example.com/video"}
+	flags := []string{"--format", "best"}
+	stor := &MockStorage{}
+	storPath := "test-path"
+
+	task := NewTask("test-id", ctx, urls, flags, stor, storPath, nil)
+
+	if task == nil {
+		t.Fatal("NewTask returned nil")
+	}
+
+	if task.ID != "test-id" {
+		t.Errorf("Expected task ID 'test-id', got '%s'", task.ID)
+	}
+
+	if len(task.URLs) != 1 || task.URLs[0] != "https://example.com/video" {
+		t.Errorf("Expected URLs to contain 'https://example.com/video', got %v", task.URLs)
+	}
+
+	if len(task.Flags) != 2 || task.Flags[0] != "--format" || task.Flags[1] != "best" {
+		t.Errorf("Expected flags to contain '--format' and 'best', got %v", task.Flags)
+	}
+
+	if task.Storage.Name() != "test-storage" {
+		t.Errorf("Expected storage name 'test-storage', got '%s'", task.Storage.Name())
+	}
+}
+
+func TestNewTaskWithoutFlags(t *testing.T) {
+	ctx := context.Background()
+	urls := []string{"https://example.com/video1", "https://example.com/video2"}
+	var flags []string // No flags
+	stor := &MockStorage{}
+	storPath := "test-path"
+
+	task := NewTask("test-id-2", ctx, urls, flags, stor, storPath, nil)
+
+	if task == nil {
+		t.Fatal("NewTask returned nil")
+	}
+
+	if len(task.URLs) != 2 {
+		t.Errorf("Expected 2 URLs, got %d", len(task.URLs))
+	}
+
+	if len(task.Flags) != 0 {
+		t.Errorf("Expected 0 flags, got %d", len(task.Flags))
+	}
+}
+
+func TestTaskTitle(t *testing.T) {
+	ctx := context.Background()
+	stor := &MockStorage{}
+
+	// Test with single URL
+	task1 := NewTask("id1", ctx, []string{"https://example.com/video"}, nil, stor, "path", nil)
+	title1 := task1.Title()
+	if title1 == "" {
+		t.Error("Task title should not be empty")
+	}
+
+	// Test with multiple URLs
+	task2 := NewTask("id2", ctx, []string{"https://example.com/v1", "https://example.com/v2"}, nil, stor, "path", nil)
+	title2 := task2.Title()
+	if title2 == "" {
+		t.Error("Task title should not be empty")
+	}
+}
+
+func TestTaskType(t *testing.T) {
+	ctx := context.Background()
+	stor := &MockStorage{}
+	task := NewTask("id", ctx, []string{"https://example.com"}, nil, stor, "path", nil)
+
+	taskType := task.Type()
+	if taskType.String() != "ytdlp" {
+		t.Errorf("Expected task type 'ytdlp', got '%s'", taskType.String())
+	}
+}
+
+func TestTaskID(t *testing.T) {
+	ctx := context.Background()
+	stor := &MockStorage{}
+	expectedID := "test-task-id-123"
+
+	task := NewTask(expectedID, ctx, []string{"https://example.com"}, nil, stor, "path", nil)
+
+	if task.TaskID() != expectedID {
+		t.Errorf("Expected task ID '%s', got '%s'", expectedID, task.TaskID())
+	}
+}

docs/content/en/_index.md

@@ -20,6 +20,9 @@ Save Any Bot is a tool that allows you to save files from Telegram to various st
 - Multi-user
 - Automatic organization based on storage rules
 - Watch specific chats and automatically save messages, with filters
+- Transfer files between different storage backends
+- Integrate with yt-dlp to download and save media from 1000+ websites
+- Aria2 integration to download files from URLs/magnets and save to storages
 - Write JS parser plugins to save files from almost any website
 - Supports multiple storage backends:
     - Alist

docs/content/en/deployment/configuration/_index.md

@@ -92,6 +92,27 @@ enable = false
 session = "data/usersession.db"
 ```
 
+### Aria2 Configuration
+
+Aria2 is a powerful download manager that supports HTTP/HTTPS, FTP, BitTorrent, and other protocols. When enabled, the bot can use the `/aria2dl` command to download files via Aria2.
+
+- `enable`: Whether to enable Aria2 support, default is `false`
+- `url`: Aria2 RPC address, typically `http://localhost:6800/jsonrpc`
+- `secret`: Aria2 RPC secret, if you configured `rpc-secret` in Aria2, you need to fill it in here
+- `remove_after_transfer`: Whether to remove local files downloaded by Aria2 after transfer, default is `true`
+
+{{< hint info >}}
+Aria2 needs to be installed and running separately. You can refer to the [Aria2 official documentation](https://aria2.github.io/) to learn how to install and configure Aria2.
+{{< /hint >}}
+
+```toml
+[aria2]
+enable = true
+url = "http://localhost:6800/jsonrpc"
+secret = "your-rpc-secret"
+remove_after_transfer = true
+```
+
 ### Storage Endpoints List
 
 The storage endpoints list is used to define the storage locations supported by the Bot. Each storage endpoint needs to specify a name, type, and related configuration, using the double bracket syntax `[[storages]]`.

docs/content/en/usage/_index.md

@@ -112,6 +112,142 @@ Regex-match the message text. For example:
 
 This will watch the chat with ID `12345678`, and only save messages whose text contains `hello`.
 
+## Direct Download Links
+
+Use the `/dl` command to directly download one or more HTTP/HTTPS files to storage.
+
+```bash
+/dl <url1> [url2] [url3] ...
+```
+
+Examples:
+
+```bash
+/dl https://example.com/file.zip
+/dl https://example.com/file1.zip https://example.com/file2.zip
+```
+
+The bot will validate the link format and then ask you to select the target storage location.
+
+## Aria2 Download
+
+{{< hint warning >}}
+This feature requires enabling Aria2 in the configuration file and configuring the RPC connection.
+{{< /hint >}}
+
+Use the `/aria2dl` command to download files via the Aria2 download manager, supporting HTTP/HTTPS, FTP, BitTorrent, and other protocols.
+
+```bash
+/aria2dl <uri1> [uri2] [uri3] ...
+```
+
+Examples:
+
+```bash
+# Download HTTP link
+/aria2dl https://example.com/file.zip
+
+# Download magnet link
+/aria2dl magnet:?xt=urn:btih:...
+
+# Download torrent file (need to upload .torrent file first)
+/aria2dl https://example.com/file.torrent
+```
+
+Configure Aria2:
+
+Add to `config.toml`:
+
+```toml
+[aria2]
+enable = true
+url = "http://localhost:6800/jsonrpc"
+secret = "your-rpc-secret"  # If rpc-secret is configured
+remove_after_transfer = true  # Remove local files after transfer
+```
+
+## yt-dlp Video Download
+
+{{< hint warning >}}
+This feature requires the yt-dlp command-line tool installed on your system.
+{{< /hint >}}
+
+Use the `/ytdlp` command to download videos and audio from supported video websites, including YouTube, Bilibili, Twitter, and 1000+ other sites.
+
+```bash
+/ytdlp <url1> [url2] [flags...]
+```
+
+Examples:
+
+```bash
+# Basic download
+/ytdlp https://www.youtube.com/watch?v=dQw4w9WgXcQ
+
+# Download multiple videos
+/ytdlp https://www.youtube.com/watch?v=video1 https://www.youtube.com/watch?v=video2
+
+# Use custom parameters
+/ytdlp https://www.youtube.com/watch?v=dQw4w9WgXcQ -f best
+/ytdlp https://www.youtube.com/watch?v=dQw4w9WgXcQ --extract-audio --audio-format mp3
+```
+
+Common parameters:
+
+- `-f <format>`: Specify download format (e.g., `best`, `worst`, `bestvideo+bestaudio`)
+- `--extract-audio`: Extract audio
+- `--audio-format <format>`: Audio format (e.g., `mp3`, `m4a`, `wav`)
+- `--write-sub`: Download subtitles
+- `--write-thumbnail`: Download thumbnail
+
+For more parameters, see [yt-dlp documentation](https://github.com/yt-dlp/yt-dlp#usage-and-options).
+
+## Storage Transfer
+
+Use the `/transfer` command to transfer files directly between different storages without going through Telegram.
+
+```bash
+/transfer <source_storage>:/<source_path> [filter]
+```
+
+Parameters:
+
+- `source_storage`: Source storage name
+- `source_path`: Source path
+- `filter`: Optional regex filter to transfer only matching files
+
+Examples:
+
+```bash
+# Transfer entire directory
+/transfer local1:/downloads
+
+# Transfer files from specified path
+/transfer alist1:/media/photos
+
+# Transfer only mp4 files
+/transfer webdav1:/videos ".*\.mp4$"
+
+# Transfer image files
+/transfer local1:/pictures "(?i)\.(jpg|png|gif)$"
+```
+
+The bot will:
+
+1. List all files in the source path
+2. Apply the filter (if provided)
+3. Display file count and total size
+4. Ask you to select the target storage
+5. Ask you to select the target directory (if configured for that storage)
+6. Start the transfer task
+
+Notes:
+
+- Source storage must support listing and reading
+- Target storage must support writing
+- Real-time progress is displayed during transfer
+- Transfer tasks can be cancelled
+
 ## Save Files Outside Telegram
 
 Besides files on Telegram, the bot can also save files from other websites via JavaScript plugins or built-in parsers.

docs/content/en/usage/api.md

@@ -1,257 +0,0 @@
----
-title: "HTTP API"
-weight: 4
----
-
-# HTTP API
-
-SaveAny-Bot provides a RESTful HTTP API for programmatic file downloads from Telegram.
-
-## Configuration
-
-Enable the API in your `config.toml`:
-
-```toml
-[api]
-# Enable HTTP API service
-enable = true
-# API server listen port
-port = 8080
-# API access token (leave empty to disable authentication)
-token = "your-secret-token-here"
-# Task completion callback webhook URL (leave empty to disable)
-webhook_url = "https://your-server.com/webhook"
-```
-
-## Authentication
-
-If `token` is configured, all API requests (except `/health`) must include an `Authorization` header:
-
-```
-Authorization: Bearer your-secret-token-here
-```
-
-## Endpoints
-
-### Health Check
-
-Check if the API server is running.
-
-**Request:**
-```
-GET /health
-```
-
-**Response:**
-```json
-{
-  "status": "ok"
-}
-```
-
-### Create Download Task
-
-Create a new file download task from a Telegram message link.
-
-**Request:**
-```
-POST /api/v1/tasks
-Content-Type: application/json
-Authorization: Bearer your-secret-token-here
-
-{
-  "telegram_url": "https://t.me/channel/123",
-  "user_id": 123456789,
-  "storage_name": "local1",
-  "dir_path": "/downloads"
-}
-```
-
-**Request Parameters:**
-- `telegram_url` (required): Telegram message link (e.g., `https://t.me/channel/123`)
-- `user_id` (required): Telegram user ID (must be configured in `config.toml`)
-- `storage_name` (optional): Storage name to use. If not specified, uses the first available storage for the user
-- `dir_path` (optional): Directory path in storage. Default is `/`
-
-**Response (201 Created):**
-```json
-{
-  "task_id": "c9h8t1234abcd",
-  "message": "task created successfully"
-}
-```
-
-**Error Response (4xx/5xx):**
-```json
-{
-  "error": "error description"
-}
-```
-
-### Get Task Status
-
-Get the status of a specific task.
-
-**Request:**
-```
-GET /api/v1/tasks/{task_id}
-Authorization: Bearer your-secret-token-here
-```
-
-**Response (200 OK):**
-```json
-{
-  "task_id": "c9h8t1234abcd",
-  "status": "completed",
-  "title": "[tgfiles](file.pdf->local1:/downloads/file.pdf)",
-  "created_at": "2024-01-19T04:30:00Z",
-  "error": ""
-}
-```
-
-**Status Values:**
-- `queued`: Task is waiting in queue
-- `running`: Task is currently downloading
-- `completed`: Task completed successfully
-- `failed`: Task failed with error (see `error` field)
-- `canceled`: Task was canceled
-
-### List All Tasks
-
-List all queued and running tasks.
-
-**Request:**
-```
-GET /api/v1/tasks
-Authorization: Bearer your-secret-token-here
-```
-
-**Response (200 OK):**
-```json
-{
-  "queued": [
-    {
-      "id": "c9h8t1234abcd",
-      "title": "[tgfiles](file1.pdf->local1:/downloads/file1.pdf)"
-    }
-  ],
-  "running": [
-    {
-      "id": "d2k9u5678efgh",
-      "title": "[tgfiles](file2.pdf->local1:/downloads/file2.pdf)"
-    }
-  ]
-}
-```
-
-### Cancel Task
-
-Cancel a running or queued task.
-
-**Request:**
-```
-DELETE /api/v1/tasks/{task_id}
-Authorization: Bearer your-secret-token-here
-```
-
-**Response (200 OK):**
-```json
-{
-  "message": "task canceled"
-}
-```
-
-## Webhook Callback
-
-If `webhook_url` is configured, the API will send a POST request to the webhook URL when a task completes or fails.
-
-**Webhook Request:**
-```
-POST {webhook_url}
-Content-Type: application/json
-Authorization: Bearer your-secret-token-here
-
-{
-  "task_id": "c9h8t1234abcd",
-  "status": "completed",
-  "title": "[tgfiles](file.pdf->local1:/downloads/file.pdf)",
-  "created_at": "2024-01-19T04:30:00Z",
-  "error": ""
-}
-```
-
-## Example Usage
-
-### Using cURL
-
-**Create a download task:**
-```bash
-curl -X POST http://localhost:8080/api/v1/tasks \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your-secret-token-here" \
-  -d '{
-    "telegram_url": "https://t.me/channel/123",
-    "user_id": 123456789,
-    "storage_name": "local1",
-    "dir_path": "/downloads"
-  }'
-```
-
-**Get task status:**
-```bash
-curl http://localhost:8080/api/v1/tasks/c9h8t1234abcd \
-  -H "Authorization: Bearer your-secret-token-here"
-```
-
-**List all tasks:**
-```bash
-curl http://localhost:8080/api/v1/tasks \
-  -H "Authorization: Bearer your-secret-token-here"
-```
-
-**Cancel a task:**
-```bash
-curl -X DELETE http://localhost:8080/api/v1/tasks/c9h8t1234abcd \
-  -H "Authorization: Bearer your-secret-token-here"
-```
-
-### Using Python
-
-```python
-import requests
-
-API_URL = "http://localhost:8080"
-TOKEN = "your-secret-token-here"
-HEADERS = {
-    "Authorization": f"Bearer {TOKEN}",
-    "Content-Type": "application/json"
-}
-
-# Create a download task
-response = requests.post(
-    f"{API_URL}/api/v1/tasks",
-    headers=HEADERS,
-    json={
-        "telegram_url": "https://t.me/channel/123",
-        "user_id": 123456789,
-        "storage_name": "local1",
-        "dir_path": "/downloads"
-    }
-)
-task_id = response.json()["task_id"]
-
-# Get task status
-response = requests.get(
-    f"{API_URL}/api/v1/tasks/{task_id}",
-    headers=HEADERS
-)
-status = response.json()
-print(f"Task status: {status['status']}")
-```
-
-## Security Recommendations
-
-1. **Always use a strong token** for production environments
-2. **Use HTTPS** in production by placing the API behind a reverse proxy (e.g., Nginx, Caddy)
-3. **Keep logs secure** as they may contain sensitive information
-4. **Validate user permissions** - ensure `user_id` in requests corresponds to authorized users in your config

docs/content/zh/_index.md

@@ -20,6 +20,9 @@ title: 介绍
 - 多用户使用
 - 基于存储规则的自动整理
 - 监听并自动转存指定聊天的消息, 支持过滤
+- 在不同存储端之间转存文件
+- 集成 yt-dlp, 从所支持的网站下载并转存媒体文件
+- 集成 Aria2, 支持直链/磁力下载和转存
 - 使用 js 编写解析器插件以转存任意网站的文件
 - 存储端支持:
   - Alist

docs/content/zh/deployment/configuration/_index.md

@@ -90,6 +90,27 @@ enable = false
 session = "data/usersession.db"
 ```
 
+### Aria2 配置
+
+Aria2 是一个强大的下载管理器，支持 HTTP/HTTPS、FTP、BitTorrent 等多种协议。启用后，Bot 可以使用 `/aria2dl` 命令通过 Aria2 下载文件。
+
+- `enable`: 是否启用 Aria2 支持，默认为 `false`
+- `url`: Aria2 RPC 地址，通常为 `http://localhost:6800/jsonrpc`
+- `secret`: Aria2 RPC 密钥，如果你在 Aria2 中配置了 `rpc-secret`，需要在此填写
+- `remove_after_transfer`: 转存完成后是否删除 Aria2 下载的本地文件，默认为 `true`
+
+{{< hint info >}}
+Aria2 需要单独安装和运行。你可以参考 [Aria2 官方文档](https://aria2.github.io/) 了解如何安装和配置 Aria2。
+{{< /hint >}}
+
+```toml
+[aria2]
+enable = true
+url = "http://localhost:6800/jsonrpc"
+secret = "your-rpc-secret"
+remove_after_transfer = true
+```
+
 ### 存储端列表
 
 存储端列表用于定义 Bot 支持的存储位置, 每个存储端需要指定名称、类型和相关配置, 使用双中括号语法 `[[storages]]` 定义.

docs/content/zh/usage/_index.md

@@ -112,6 +112,142 @@ IS-ALBUM true MyWebdav NEW-FOR-ALBUM
 
 这将会监听 ID 为 12345678 的聊天, 并且只保存消息文本中包含 "hello" 的消息.
 
+## 直接下载链接
+
+使用 `/dl` 命令可以直接下载一个或多个 HTTP/HTTPS 链接的文件到存储中.
+
+```bash
+/dl <url1> [url2] [url3] ...
+```
+
+示例:
+
+```bash
+/dl https://example.com/file.zip
+/dl https://example.com/file1.zip https://example.com/file2.zip
+```
+
+Bot 会验证链接格式, 然后让你选择目标存储位置.
+
+## Aria2 下载
+
+{{< hint warning >}}
+该功能需要在配置文件中启用 Aria2 并配置 RPC 连接.
+{{< /hint >}}
+
+使用 `/aria2dl` 命令可以通过 Aria2 下载管理器下载文件, 支持 HTTP/HTTPS、FTP、BitTorrent 等多种协议.
+
+```bash
+/aria2dl <uri1> [uri2] [uri3] ...
+```
+
+示例:
+
+```bash
+# 下载 HTTP 链接
+/aria2dl https://example.com/file.zip
+
+# 下载磁力链接
+/aria2dl magnet:?xt=urn:btih:...
+
+# 下载种子文件 (需要先上传 .torrent 文件)
+/aria2dl https://example.com/file.torrent
+```
+
+配置 Aria2:
+
+在 `config.toml` 中添加:
+
+```toml
+[aria2]
+enable = true
+url = "http://localhost:6800/jsonrpc"
+secret = "your-rpc-secret"  # 如果配置了 rpc-secret
+remove_after_transfer = true  # 转存完成后删除本地文件
+```
+
+## yt-dlp 视频下载
+
+{{< hint warning >}}
+该功能需要在系统中安装 yt-dlp 命令行工具.
+{{< /hint >}}
+
+使用 `/ytdlp` 命令可以下载支持的视频网站的视频和音频, 支持 YouTube、Bilibili、Twitter 等 1000+ 个网站.
+
+```bash
+/ytdlp <url1> [url2] [flags...]
+```
+
+示例:
+
+```bash
+# 基本下载
+/ytdlp https://www.youtube.com/watch?v=dQw4w9WgXcQ
+
+# 下载多个视频
+/ytdlp https://www.youtube.com/watch?v=video1 https://www.youtube.com/watch?v=video2
+
+# 使用自定义参数
+/ytdlp https://www.youtube.com/watch?v=dQw4w9WgXcQ -f best
+/ytdlp https://www.youtube.com/watch?v=dQw4w9WgXcQ --extract-audio --audio-format mp3
+```
+
+常用参数:
+
+- `-f <format>`: 指定下载格式 (如 `best`, `worst`, `bestvideo+bestaudio`)
+- `--extract-audio`: 提取音频
+- `--audio-format <format>`: 音频格式 (如 `mp3`, `m4a`, `wav`)
+- `--write-sub`: 下载字幕
+- `--write-thumbnail`: 下载缩略图
+
+更多参数请参考 [yt-dlp 文档](https://github.com/yt-dlp/yt-dlp#usage-and-options).
+
+## 存储间传输
+
+使用 `/transfer` 命令可以在不同存储之间直接传输文件, 无需经过 Telegram.
+
+```bash
+/transfer <source_storage>:/<source_path> [filter]
+```
+
+参数说明:
+
+- `source_storage`: 源存储名称
+- `source_path`: 源路径
+- `filter`: 可选的正则表达式过滤器, 只传输匹配的文件
+
+示例:
+
+```bash
+# 传输整个目录
+/transfer local1:/downloads
+
+# 传输指定路径的文件
+/transfer alist1:/media/photos
+
+# 只传输 mp4 文件
+/transfer webdav1:/videos ".*\.mp4$"
+
+# 传输图片文件
+/transfer local1:/pictures "(?i)\.(jpg|png|gif)$"
+```
+
+Bot 会:
+
+1. 列出源路径下的所有文件
+2. 应用过滤器 (如果提供)
+3. 显示文件数量和总大小
+4. 让你选择目标存储
+5. 让你选择目标目录 (如果该存储配置了目录)
+6. 开始传输任务
+
+注意:
+
+- 源存储必须支持列举和读取功能
+- 目标存储必须支持写入功能
+- 传输过程显示实时进度
+- 支持取消正在进行的传输任务
+
 ## 转存 Telegram 之外的文件
 
 除了 Telegram 上的文件, Bot 还可通过 JavaScript 插件或内置解析器来支持转存其他网站的文件.

docs/content/zh/usage/api.md

@@ -1,257 +0,0 @@
----
-title: "HTTP API"
-weight: 4
----
-
-# HTTP API
-
-SaveAny-Bot 提供 RESTful HTTP API，支持通过编程方式从 Telegram 下载文件。
-
-## 配置
-
-在 `config.toml` 中启用 API：
-
-```toml
-[api]
-# 启用 HTTP API 服务
-enable = true
-# API 服务监听端口
-port = 8080
-# API 访问令牌 (留空则不验证)
-token = "your-secret-token-here"
-# 任务完成回调 Webhook URL (留空则不回调)
-webhook_url = "https://your-server.com/webhook"
-```
-
-## 认证
-
-如果配置了 `token`，所有 API 请求（除了 `/health`）都必须包含 `Authorization` 头：
-
-```
-Authorization: Bearer your-secret-token-here
-```
-
-## 端点
-
-### 健康检查
-
-检查 API 服务器是否正在运行。
-
-**请求：**
-```
-GET /health
-```
-
-**响应：**
-```json
-{
-  "status": "ok"
-}
-```
-
-### 创建下载任务
-
-从 Telegram 消息链接创建新的文件下载任务。
-
-**请求：**
-```
-POST /api/v1/tasks
-Content-Type: application/json
-Authorization: Bearer your-secret-token-here
-
-{
-  "telegram_url": "https://t.me/channel/123",
-  "user_id": 123456789,
-  "storage_name": "local1",
-  "dir_path": "/downloads"
-}
-```
-
-**请求参数：**
-- `telegram_url` (必填): Telegram 消息链接 (例如: `https://t.me/channel/123`)
-- `user_id` (必填): Telegram 用户 ID (必须在 `config.toml` 中配置)
-- `storage_name` (可选): 要使用的存储名称。如果未指定，使用用户的第一个可用存储
-- `dir_path` (可选): 存储中的目录路径。默认为 `/`
-
-**响应 (201 Created)：**
-```json
-{
-  "task_id": "c9h8t1234abcd",
-  "message": "task created successfully"
-}
-```
-
-**错误响应 (4xx/5xx)：**
-```json
-{
-  "error": "错误描述"
-}
-```
-
-### 获取任务状态
-
-获取特定任务的状态。
-
-**请求：**
-```
-GET /api/v1/tasks/{task_id}
-Authorization: Bearer your-secret-token-here
-```
-
-**响应 (200 OK)：**
-```json
-{
-  "task_id": "c9h8t1234abcd",
-  "status": "completed",
-  "title": "[tgfiles](file.pdf->local1:/downloads/file.pdf)",
-  "created_at": "2024-01-19T04:30:00Z",
-  "error": ""
-}
-```
-
-**状态值：**
-- `queued`: 任务正在队列中等待
-- `running`: 任务正在下载
-- `completed`: 任务成功完成
-- `failed`: 任务失败（查看 `error` 字段）
-- `canceled`: 任务已取消
-
-### 列出所有任务
-
-列出所有排队和正在运行的任务。
-
-**请求：**
-```
-GET /api/v1/tasks
-Authorization: Bearer your-secret-token-here
-```
-
-**响应 (200 OK)：**
-```json
-{
-  "queued": [
-    {
-      "id": "c9h8t1234abcd",
-      "title": "[tgfiles](file1.pdf->local1:/downloads/file1.pdf)"
-    }
-  ],
-  "running": [
-    {
-      "id": "d2k9u5678efgh",
-      "title": "[tgfiles](file2.pdf->local1:/downloads/file2.pdf)"
-    }
-  ]
-}
-```
-
-### 取消任务
-
-取消正在运行或排队的任务。
-
-**请求：**
-```
-DELETE /api/v1/tasks/{task_id}
-Authorization: Bearer your-secret-token-here
-```
-
-**响应 (200 OK)：**
-```json
-{
-  "message": "task canceled"
-}
-```
-
-## Webhook 回调
-
-如果配置了 `webhook_url`，API 会在任务完成或失败时向 webhook URL 发送 POST 请求。
-
-**Webhook 请求：**
-```
-POST {webhook_url}
-Content-Type: application/json
-Authorization: Bearer your-secret-token-here
-
-{
-  "task_id": "c9h8t1234abcd",
-  "status": "completed",
-  "title": "[tgfiles](file.pdf->local1:/downloads/file.pdf)",
-  "created_at": "2024-01-19T04:30:00Z",
-  "error": ""
-}
-```
-
-## 使用示例
-
-### 使用 cURL
-
-**创建下载任务：**
-```bash
-curl -X POST http://localhost:8080/api/v1/tasks \
-  -H "Content-Type: application/json" \
-  -H "Authorization: Bearer your-secret-token-here" \
-  -d '{
-    "telegram_url": "https://t.me/channel/123",
-    "user_id": 123456789,
-    "storage_name": "local1",
-    "dir_path": "/downloads"
-  }'
-```
-
-**获取任务状态：**
-```bash
-curl http://localhost:8080/api/v1/tasks/c9h8t1234abcd \
-  -H "Authorization: Bearer your-secret-token-here"
-```
-
-**列出所有任务：**
-```bash
-curl http://localhost:8080/api/v1/tasks \
-  -H "Authorization: Bearer your-secret-token-here"
-```
-
-**取消任务：**
-```bash
-curl -X DELETE http://localhost:8080/api/v1/tasks/c9h8t1234abcd \
-  -H "Authorization: Bearer your-secret-token-here"
-```
-
-### 使用 Python
-
-```python
-import requests
-
-API_URL = "http://localhost:8080"
-TOKEN = "your-secret-token-here"
-HEADERS = {
-    "Authorization": f"Bearer {TOKEN}",
-    "Content-Type": "application/json"
-}
-
-# 创建下载任务
-response = requests.post(
-    f"{API_URL}/api/v1/tasks",
-    headers=HEADERS,
-    json={
-        "telegram_url": "https://t.me/channel/123",
-        "user_id": 123456789,
-        "storage_name": "local1",
-        "dir_path": "/downloads"
-    }
-)
-task_id = response.json()["task_id"]
-
-# 获取任务状态
-response = requests.get(
-    f"{API_URL}/api/v1/tasks/{task_id}",
-    headers=HEADERS
-)
-status = response.json()
-print(f"任务状态: {status['status']}")
-```
-
-## 安全建议
-
-1. **生产环境始终使用强令牌**
-2. **生产环境使用 HTTPS**，通过反向代理（如 Nginx、Caddy）放置 API
-3. **保护日志安全**，因为它们可能包含敏感信息
-4. **验证用户权限** - 确保请求中的 `user_id` 对应于配置中的授权用户

docs/go.mod

@@ -1,5 +1,3 @@
 module github.com/krau/SaveAny-Bot/docs
 
 go 1.24.4
-
-require github.com/alex-shpak/hugo-book v0.0.0-20250530233833-f2c703e15588 // indirect

docs/go.sum

@@ -1,2 +0,0 @@
-github.com/alex-shpak/hugo-book v0.0.0-20250530233833-f2c703e15588 h1:pwxkzpzw/iJSxMBgQLWjYMQubhIemLG3UrNjeWoCkSM=
-github.com/alex-shpak/hugo-book v0.0.0-20250530233833-f2c703e15588/go.mod h1:L4NMyzbn15fpLIpmmtDg9ZFFyTZzw87/lk7M2bMQ7ds=

pkg/enums/ctxkey/context_key.go

@@ -1,5 +1,6 @@
 package ctxkey
 
-//go:generate go-enum --values --names --flag --nocase --noprefix
 // ENUM(content-length)
+//
+//go:generate go-enum --values --names --flag --nocase --noprefix
 type ContextKey string

pkg/enums/tasktype/tasktype.go

@@ -1,5 +1,5 @@
 package tasktype
 
 //go:generate go-enum --values --names --flag --nocase
-// ENUM(tgfiles,tphpics,parseditem,directlinks,aria2,ytdlp)
+// ENUM(tgfiles,tphpics,parseditem,directlinks,aria2,ytdlp,transfer)
 type TaskType string

pkg/enums/tasktype/tasktype_enum.go

@@ -24,6 +24,8 @@ const (
 	TaskTypeAria2 TaskType = "aria2"
 	// TaskTypeYtdlp is a TaskType of type ytdlp.
 	TaskTypeYtdlp TaskType = "ytdlp"
+	// TaskTypeTransfer is a TaskType of type transfer.
+	TaskTypeTransfer TaskType = "transfer"
 )
 
 var ErrInvalidTaskType = fmt.Errorf("not a valid TaskType, try [%s]", strings.Join(_TaskTypeNames, ", "))
@@ -35,6 +37,7 @@ var _TaskTypeNames = []string{
 	string(TaskTypeDirectlinks),
 	string(TaskTypeAria2),
 	string(TaskTypeYtdlp),
+	string(TaskTypeTransfer),
 }
 
 // TaskTypeNames returns a list of possible string values of TaskType.
@@ -53,6 +56,7 @@ func TaskTypeValues() []TaskType {
 		TaskTypeDirectlinks,
 		TaskTypeAria2,
 		TaskTypeYtdlp,
+		TaskTypeTransfer,
 	}
 }
 
@@ -75,6 +79,7 @@ var _TaskTypeValue = map[string]TaskType{
 	"directlinks": TaskTypeDirectlinks,
 	"aria2":       TaskTypeAria2,
 	"ytdlp":       TaskTypeYtdlp,
+	"transfer":    TaskTypeTransfer,
 }
 
 // ParseTaskType attempts to convert a string to a TaskType.

pkg/storagetypes/fileinfo.go

@@ -0,0 +1,12 @@
+package storagetypes
+
+import "time"
+
+// FileInfo represents file metadata
+type FileInfo struct {
+	Name    string
+	Path    string
+	Size    int64
+	IsDir   bool
+	ModTime time.Time
+}

pkg/tcbdata/data.go

@@ -48,7 +48,12 @@ type Add struct {
 	// aria2
 	Aria2URIs []string
 	// ytdlp
-	YtdlpURLs []string
+	YtdlpURLs  []string
+	YtdlpFlags []string
+	// transfer
+	TransferSourceStorName string
+	TransferSourcePath     string
+	TransferFiles          []string // file paths relative to source storage
 }
 
 type SetDefaultStorage struct {

storage/alist/alist.go

@@ -16,6 +16,7 @@ import (
 	config "github.com/krau/SaveAny-Bot/config/storage"
 	"github.com/krau/SaveAny-Bot/pkg/enums/ctxkey"
 	storenum "github.com/krau/SaveAny-Bot/pkg/enums/storage"
+	"github.com/krau/SaveAny-Bot/pkg/storagetypes"
 )
 
 type Alist struct {
@@ -215,3 +216,156 @@ func (a *Alist) Exists(ctx context.Context, storagePath string) bool {
 func (a *Alist) CannotStream() string {
 	return "Alist does not support chunked transfer encoding"
 }
+
+// ListFiles implements StorageListable interface
+func (a *Alist) ListFiles(ctx context.Context, dirPath string) ([]storagetypes.FileInfo, error) {
+	a.logger.Debugf("Listing files in directory: %s", dirPath)
+
+	reqBody := fsListRequest{
+		Path:     dirPath,
+		Password: "",
+		Page:     1,
+		PerPage:  0, // 0 means all files
+		Refresh:  false,
+	}
+
+	bodyBytes, err := json.Marshal(reqBody)
+	if err != nil {
+		return nil, fmt.Errorf("failed to marshal request body: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, a.baseURL+"/api/fs/list", bytes.NewBuffer(bodyBytes))
+	if err != nil {
+		return nil, fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("Authorization", a.token)
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := a.client.Do(req)
+	if err != nil {
+		return nil, fmt.Errorf("failed to send request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, fmt.Errorf("failed to list files: %s", resp.Status)
+	}
+
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	var listResp fsListResponse
+	if err := json.Unmarshal(data, &listResp); err != nil {
+		return nil, fmt.Errorf("failed to unmarshal list response: %w", err)
+	}
+
+	if listResp.Code != http.StatusOK {
+		return nil, fmt.Errorf("failed to list files: %d, %s", listResp.Code, listResp.Message)
+	}
+
+	files := make([]storagetypes.FileInfo, 0, len(listResp.Data.Content))
+	for _, item := range listResp.Data.Content {
+		// Parse modified time; log failures but keep zero value on error.
+		var modTime time.Time
+		if item.Modified != "" {
+			parsedTime, err := time.Parse(time.RFC3339, item.Modified)
+			if err != nil {
+				a.logger.With(
+					"path", path.Join(dirPath, item.Name),
+					"modified_raw", item.Modified,
+				).Warnf("failed to parse modified time for file")
+			} else {
+				modTime = parsedTime
+			}
+		}
+
+		files = append(files, storagetypes.FileInfo{
+			Name:    item.Name,
+			Path:    path.Join(dirPath, item.Name),
+			Size:    item.Size,
+			IsDir:   item.IsDir,
+			ModTime: modTime,
+		})
+	}
+
+	a.logger.Debugf("Found %d files in directory %s", len(files), dirPath)
+	return files, nil
+}
+
+// OpenFile implements StorageReadable interface
+func (a *Alist) OpenFile(ctx context.Context, filePath string) (io.ReadCloser, int64, error) {
+	a.logger.Debugf("Opening file: %s", filePath)
+
+	// First, get file info to get the raw_url
+	reqBody := map[string]any{
+		"path":     filePath,
+		"password": "",
+	}
+
+	bodyBytes, err := json.Marshal(reqBody)
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to marshal request body: %w", err)
+	}
+
+	req, err := http.NewRequestWithContext(ctx, http.MethodPost, a.baseURL+"/api/fs/get", bytes.NewBuffer(bodyBytes))
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to create request: %w", err)
+	}
+	req.Header.Set("Authorization", a.token)
+	req.Header.Set("Content-Type", "application/json")
+
+	resp, err := a.client.Do(req)
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to send request: %w", err)
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusOK {
+		return nil, 0, fmt.Errorf("failed to get file info: %s", resp.Status)
+	}
+
+	data, err := io.ReadAll(resp.Body)
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to read response body: %w", err)
+	}
+
+	var getResp fsGetResponse
+	if err := json.Unmarshal(data, &getResp); err != nil {
+		return nil, 0, fmt.Errorf("failed to unmarshal get response: %w", err)
+	}
+
+	if getResp.Code != http.StatusOK {
+		return nil, 0, fmt.Errorf("failed to get file info: %d, %s", getResp.Code, getResp.Message)
+	}
+
+	if getResp.Data.IsDir {
+		return nil, 0, fmt.Errorf("path is a directory, not a file")
+	}
+
+	// Download the file from raw_url
+	downloadURL := getResp.Data.RawURL
+	if downloadURL == "" {
+		// If no raw_url, construct download URL
+		downloadURL = a.baseURL + "/d" + filePath
+	}
+
+	downloadReq, err := http.NewRequestWithContext(ctx, http.MethodGet, downloadURL, nil)
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to create download request: %w", err)
+	}
+
+	downloadResp, err := a.client.Do(downloadReq)
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to download file: %w", err)
+	}
+
+	if downloadResp.StatusCode != http.StatusOK {
+		downloadResp.Body.Close()
+		return nil, 0, fmt.Errorf("failed to download file: %s", downloadResp.Status)
+	}
+
+	a.logger.Debugf("Opened file %s, size: %d bytes", filePath, getResp.Data.Size)
+	return downloadResp.Body, getResp.Data.Size, nil
+}

storage/alist/types.go

@@ -46,4 +46,46 @@ type putResponse struct {
 type fsGetResponse struct {
 	Code    int    `json:"code"`
 	Message string `json:"message"`
+	Data    struct {
+		Name     string `json:"name"`
+		Size     int64  `json:"size"`
+		IsDir    bool   `json:"is_dir"`
+		Modified string `json:"modified"`
+		Created  string `json:"created"`
+		Sign     string `json:"sign"`
+		Thumb    string `json:"thumb"`
+		Type     int    `json:"type"`
+		RawURL   string `json:"raw_url"`
+		Provider string `json:"provider"`
+	} `json:"data"`
+}
+
+type fsListRequest struct {
+	Path     string `json:"path"`
+	Password string `json:"password"`
+	Page     int    `json:"page"`
+	PerPage  int    `json:"per_page"`
+	Refresh  bool   `json:"refresh"`
+}
+
+type fsListResponse struct {
+	Code    int    `json:"code"`
+	Message string `json:"message"`
+	Data    struct {
+		Content []struct {
+			Name     string `json:"name"`
+			Size     int64  `json:"size"`
+			IsDir    bool   `json:"is_dir"`
+			Modified string `json:"modified"`
+			Created  string `json:"created"`
+			Sign     string `json:"sign"`
+			Thumb    string `json:"thumb"`
+			Type     int    `json:"type"`
+		} `json:"content"`
+		Total    int64  `json:"total"`
+		Readme   string `json:"readme"`
+		Header   string `json:"header"`
+		Write    bool   `json:"write"`
+		Provider string `json:"provider"`
+	} `json:"data"`
 }

storage/load.go

@@ -6,6 +6,7 @@ import (
 
 	"github.com/charmbracelet/log"
 	"github.com/krau/SaveAny-Bot/config"
+	storenum "github.com/krau/SaveAny-Bot/pkg/enums/storage"
 )
 
 var UserStorages = make(map[int64][]Storage)
@@ -79,3 +80,14 @@ func LoadStorages(ctx context.Context) {
 		UserStorages[int64(user)] = GetUserStorages(ctx, int64(user))
 	}
 }
+
+// GetTelegramStorageByUserID returns the first enabled Telegram storage for the user
+func GetTelegramStorageByUserID(ctx context.Context, chatID int64) (Storage, error) {
+	storages := GetUserStorages(ctx, chatID)
+	for _, stor := range storages {
+		if stor.Type() == storenum.Telegram {
+			return stor, nil
+		}
+	}
+	return nil, fmt.Errorf("no telegram storage found for user %d", chatID)
+}

storage/local/local.go

@@ -12,6 +12,7 @@ import (
 	"github.com/duke-git/lancet/v2/fileutil"
 	config "github.com/krau/SaveAny-Bot/config/storage"
 	storenum "github.com/krau/SaveAny-Bot/pkg/enums/storage"
+	"github.com/krau/SaveAny-Bot/pkg/storagetypes"
 )
 
 type Local struct {
@@ -50,6 +51,7 @@ func (l *Local) JoinStoragePath(path string) string {
 
 func (l *Local) Save(ctx context.Context, r io.Reader, storagePath string) error {
 	l.logger.Infof("Saving file to %s", storagePath)
+	storagePath = l.JoinStoragePath(storagePath)
 
 	ext := filepath.Ext(storagePath)
 	base := strings.TrimSuffix(storagePath, ext)
@@ -81,3 +83,51 @@ func (l *Local) Exists(ctx context.Context, storagePath string) bool {
 	}
 	return fileutil.IsExist(absPath)
 }
+
+// ListFiles implements StorageListable interface
+func (l *Local) ListFiles(ctx context.Context, dirPath string) ([]storagetypes.FileInfo, error) {
+	absPath := l.JoinStoragePath(dirPath)
+	
+	entries, err := os.ReadDir(absPath)
+	if err != nil {
+		return nil, fmt.Errorf("failed to read directory %s: %w", absPath, err)
+	}
+	
+	files := make([]storagetypes.FileInfo, 0, len(entries))
+	for _, entry := range entries {
+		info, err := entry.Info()
+		if err != nil {
+			l.logger.Warnf("Failed to get file info for %s: %v", entry.Name(), err)
+			continue
+		}
+		
+		filePath := filepath.Join(dirPath, entry.Name())
+		files = append(files, storagetypes.FileInfo{
+			Name:    entry.Name(),
+			Path:    filePath,
+			Size:    info.Size(),
+			IsDir:   entry.IsDir(),
+			ModTime: info.ModTime(),
+		})
+	}
+	
+	return files, nil
+}
+
+// OpenFile implements StorageReadable interface
+func (l *Local) OpenFile(ctx context.Context, filePath string) (io.ReadCloser, int64, error) {
+	absPath := l.JoinStoragePath(filePath)
+	
+	file, err := os.Open(absPath)
+	if err != nil {
+		return nil, 0, fmt.Errorf("failed to open file %s: %w", absPath, err)
+	}
+	
+	stat, err := file.Stat()
+	if err != nil {
+		file.Close()
+		return nil, 0, fmt.Errorf("failed to stat file %s: %w", absPath, err)
+	}
+	
+	return file, stat.Size(), nil
+}

storage/minio/client.go

@@ -77,13 +77,13 @@ func (m *Minio) JoinStoragePath(p string) string {
 
 func (m *Minio) Save(ctx context.Context, r io.Reader, storagePath string) error {
 	m.logger.Infof("Saving file from reader to %s", storagePath)
-
+	storagePath = m.JoinStoragePath(storagePath)
 	ext := path.Ext(storagePath)
 	base := strings.TrimSuffix(storagePath, ext)
 	candidate := storagePath
 	for i := 1; m.Exists(ctx, candidate); i++ {
 		candidate = fmt.Sprintf("%s_%d%s", base, i, ext)
-		if i > 100 {
+		if i > 10 {
 			m.logger.Errorf("Too many attempts to find a unique filename for %s", storagePath)
 			candidate = fmt.Sprintf("%s_%s%s", base, xid.New().String(), ext)
 			break

storage/s3/s3.go

@@ -65,7 +65,7 @@ func (m *S3) JoinStoragePath(p string) string {
 
 func (m *S3) Save(ctx context.Context, r io.Reader, storagePath string) error {
 	m.logger.Infof("Saving file from reader to %s", storagePath)
-
+	storagePath = m.JoinStoragePath(storagePath)
 	ext := path.Ext(storagePath)
 	base := strings.TrimSuffix(storagePath, ext)
 	candidate := storagePath
@@ -73,7 +73,7 @@ func (m *S3) Save(ctx context.Context, r io.Reader, storagePath string) error {
 	// Unique filename
 	for i := 1; m.Exists(ctx, candidate); i++ {
 		candidate = fmt.Sprintf("%s_%d%s", base, i, ext)
-		if i > 100 {
+		if i > 10 {
 			m.logger.Errorf("Too many attempts for unique filename: %s", storagePath)
 			candidate = fmt.Sprintf("%s_%s%s", base, xid.New().String(), ext)
 			break

storage/storage.go

@@ -7,6 +7,7 @@ import (
 
 	storcfg "github.com/krau/SaveAny-Bot/config/storage"
 	storenum "github.com/krau/SaveAny-Bot/pkg/enums/storage"
+	"github.com/krau/SaveAny-Bot/pkg/storagetypes"
 	"github.com/krau/SaveAny-Bot/storage/alist"
 	"github.com/krau/SaveAny-Bot/storage/local"
 	"github.com/krau/SaveAny-Bot/storage/minio"
@@ -20,7 +21,6 @@ type Storage interface {
 	Init(ctx context.Context, cfg storcfg.StorageConfig) error
 	Type() storenum.StorageType
 	Name() string
-	JoinStoragePath(p string) string
 	Save(ctx context.Context, reader io.Reader, storagePath string) error
 	Exists(ctx context.Context, storagePath string) bool
 }
@@ -30,6 +30,18 @@ type StorageCannotStream interface {
 	CannotStream() string
 }
 
+// StorageListable 表示支持列举目录内容的存储
+type StorageListable interface {
+	Storage
+	ListFiles(ctx context.Context, dirPath string) ([]storagetypes.FileInfo, error)
+}
+
+// StorageReadable 表示支持读取文件内容的存储
+type StorageReadable interface {
+	Storage
+	OpenFile(ctx context.Context, filePath string) (io.ReadCloser, int64, error)
+}
+
 var Storages = make(map[string]Storage)
 
 type StorageConstructor func() Storage

storage/telegram/split.go

@@ -99,12 +99,6 @@ func (w *splitWriter) finalize() error {
 }
 
 func CreateSplitZip(ctx context.Context, reader io.Reader, size int64, fileName, outputBase string, partSize int64) error {
-	// seek the reader if possible
-	if rs, ok := reader.(io.ReadSeeker); ok {
-		if _, err := rs.Seek(0, io.SeekStart); err != nil {
-			return fmt.Errorf("failed to seek reader: %w", err)
-		}
-	}
 	outputDir := filepath.Dir(outputBase)
 	if err := os.MkdirAll(outputDir, os.ModePerm); err != nil {
 		return fmt.Errorf("failed to create output directory: %w", err)

storage/telegram/telegram.go

@@ -66,15 +66,12 @@ func (t *Telegram) Name() string {
 	return t.config.Name
 }
 
-func (t *Telegram) JoinStoragePath(p string) string {
-	return path.Clean(p)
-}
-
 func (t *Telegram) Exists(ctx context.Context, storagePath string) bool {
 	return false
 }
 
 func (t *Telegram) Save(ctx context.Context, r io.Reader, storagePath string) error {
+	storagePath = path.Clean(storagePath)
 	tctx := tgutil.ExtFromContext(ctx)
 	if tctx == nil {
 		return fmt.Errorf("failed to get telegram context")
@@ -92,9 +89,6 @@ func (t *Telegram) Save(ctx context.Context, r io.Reader, storagePath string) er
 		return nil
 	}
 	rs, seekable := r.(io.ReadSeeker)
-	if !seekable || rs == nil {
-		return fmt.Errorf("reader must implement io.ReadSeeker")
-	}
 	splitSize := t.config.SplitSizeMB * 1024 * 1024
 	if splitSize <= 0 {
 		splitSize = DefaultSplitSize
@@ -123,88 +117,96 @@ func (t *Telegram) Save(ctx context.Context, r io.Reader, storagePath string) er
 		}
 		chatID = cid
 	}
-	mtype, err := mimetype.DetectReader(rs)
+	upler := uploader.NewUploader(tctx.Raw).
-	if err != nil {
+		WithPartSize(tglimit.MaxUploadPartSize).
-		return fmt.Errorf("failed to detect mimetype: %w", err)
+		WithThreads(dlutil.BestThreads(size, config.C().Threads))
-	}
-	if filename == "" {
-		filename = xid.New().String() + mtype.Extension()
-	}
 	peer := tryGetInputPeer(tctx, chatID)
 	if peer == nil || peer.Zero() {
 		return fmt.Errorf("failed to get input peer for chat ID %d", chatID)
 	}
+	var mtype *mimetype.MIME
+	if seekable {
+		var err error
+		mtype, err = mimetype.DetectReader(rs)
+		if err != nil {
+			return fmt.Errorf("failed to detect mimetype: %w", err)
+		}
+		if filename == "" {
+			filename = xid.New().String() + mtype.Extension()
+		}
 
-	if _, err := rs.Seek(0, io.SeekStart); err != nil {
+		if _, err := rs.Seek(0, io.SeekStart); err != nil {
-		return fmt.Errorf("failed to seek reader: %w", err)
+			return fmt.Errorf("failed to seek reader: %w", err)
+		}
 	}
-	upler := uploader.NewUploader(tctx.Raw).
-		WithPartSize(tglimit.MaxUploadPartSize).
-		WithThreads(dlutil.BestThreads(size, config.C().Threads))
 	if size > splitSize {
 		// large file, use split uploader
-		return t.splitUpload(tctx, rs, filename, upler, peer, size, splitSize)
+		return t.splitUpload(tctx, r, filename, upler, peer, size, splitSize)
 	}
 
 	var file tg.InputFileClass
-	if size < 0 {
+	var err error
-		file, err = upler.FromReader(ctx, filename, rs)
+	if size <= 0 {
+		file, err = upler.FromReader(ctx, filename, r)
 	} else {
-		file, err = upler.Upload(ctx, uploader.NewUpload(filename, rs, size))
+		file, err = upler.Upload(ctx, uploader.NewUpload(filename, r, size))
 	}
 	if err != nil {
 		return fmt.Errorf("failed to upload file to telegram: %w", err)
 	}
 	caption := styling.Plain(filename)
 	forceFile := t.config.ForceFile
-	if strings.HasPrefix(mtype.String(), "image/") && size >= tglimit.MaxPhotoSize {
+
+	if mtype != nil && strings.HasPrefix(mtype.String(), "image/") && size >= tglimit.MaxPhotoSize {
 		forceFile = true
 	}
 	doc := message.UploadedDocument(file, caption).
 		Filename(filename).
-		ForceFile(forceFile).
+		ForceFile(forceFile)
-		MIME(mtype.String())
+	if mtype != nil {
-
+		doc = doc.MIME(mtype.String())
+	}
 	var media message.MediaOption = doc
-
+	if mtype != nil && rs != nil {
-	switch mtypeStr := mtype.String(); {
+		switch mtypeStr := mtype.String(); {
-	case strings.HasPrefix(mtypeStr, "video/"):
+		case strings.HasPrefix(mtypeStr, "video/"):
-		media = doc.Video().SupportsStreaming()
+			media = doc.Video().SupportsStreaming()
-		thumb, err := extractThumbFrame(rs)
+			thumb, err := extractThumbFrame(rs)
-		if err == nil {
-			thumb, err := upler.FromBytes(ctx, "thumb.jpg", thumb)
 			if err == nil {
-				doc = doc.Thumb(thumb)
+				thumb, err := upler.FromBytes(ctx, "thumb.jpg", thumb)
+				if err == nil {
+					doc = doc.Thumb(thumb)
+				}
 			}
+			rs.Seek(0, io.SeekStart)
+			switch mtypeStr {
+			case "video/mp4":
+				info, err := getMP4Meta(rs)
+				if err != nil {
+					// Fallback to ffprobe if gomedia fails (e.g., malformed MP4)
+					rs.Seek(0, io.SeekStart)
+					info, err = getVideoMetadata(rs)
+				}
+				if err == nil {
+					media = doc.Video().
+						Duration(time.Duration(info.Duration)*time.Second).
+						Resolution(info.Width, info.Height).
+						SupportsStreaming()
+				}
+			default:
+				info, err := getVideoMetadata(rs)
+				if err == nil {
+					media = doc.Video().
+						Duration(time.Duration(info.Duration)*time.Second).
+						Resolution(info.Width, info.Height).
+						SupportsStreaming()
+				}
+			}
+		case strings.HasPrefix(mtypeStr, "audio/"):
+			media = doc.Audio().Title(filename)
+		case strings.HasPrefix(mtypeStr, "image/") && !strings.HasSuffix(mtypeStr, "webp"):
+			media = message.UploadedPhoto(file, caption)
 		}
-		rs.Seek(0, io.SeekStart)
-		switch mtypeStr {
-		case "video/mp4":
-			info, err := getMP4Meta(rs)
-			if err != nil {
-				// Fallback to ffprobe if gomedia fails (e.g., malformed MP4)
-				rs.Seek(0, io.SeekStart)
-				info, err = getVideoMetadata(rs)
-			}
-			if err == nil {
-				media = doc.Video().
-					Duration(time.Duration(info.Duration)*time.Second).
-					Resolution(info.Width, info.Height).
-					SupportsStreaming()
-			}
-		default:
-			info, err := getVideoMetadata(rs)
-			if err == nil {
-				media = doc.Video().
-					Duration(time.Duration(info.Duration)*time.Second).
-					Resolution(info.Width, info.Height).
-					SupportsStreaming()
-			}
-		}
-	case strings.HasPrefix(mtypeStr, "audio/"):
-		media = doc.Audio().Title(filename)
-	case strings.HasPrefix(mtypeStr, "image/") && !strings.HasSuffix(mtypeStr, "webp"):
-		media = message.UploadedPhoto(file, caption)
 	}
 	sender := tctx.Sender
 	_, err = sender.WithUploader(upler).To(peer).Media(ctx, media)
@@ -215,7 +217,7 @@ func (t *Telegram) CannotStream() string {
 	return "Telegram storage must use a ReaderSeeker"
 }
 
-func (t *Telegram) splitUpload(ctx *ext.Context, rs io.ReadSeeker, filename string, upler *uploader.Uploader, peer tg.InputPeerClass, fileSize, splitSize int64) error {
+func (t *Telegram) splitUpload(ctx *ext.Context, r io.Reader, filename string, upler *uploader.Uploader, peer tg.InputPeerClass, fileSize, splitSize int64) error {
 	tempId := xid.New().String()
 	outputBase := filepath.Join(config.C().Temp.BasePath, tempId, strings.Split(filename, ".")[0])
 	defer func() {
@@ -224,7 +226,7 @@ func (t *Telegram) splitUpload(ctx *ext.Context, rs io.ReadSeeker, filename stri
 			log.FromContext(ctx).Warnf("Failed to cleanup temp split files: %s", err)
 		}
 	}()
-	if err := CreateSplitZip(ctx, rs, fileSize, filename, outputBase, splitSize); err != nil {
+	if err := CreateSplitZip(ctx, r, fileSize, filename, outputBase, splitSize); err != nil {
 		return fmt.Errorf("failed to create split zip: %w", err)
 	}
 	matched, err := filepath.Glob(outputBase + ".z*")

storage/webdav/client.go

@@ -2,6 +2,7 @@ package webdav
 
 import (
 	"context"
+	"encoding/xml"
 	"fmt"
 	"io"
 	"net/http"
@@ -25,8 +26,40 @@ const (
 	WebdavMethodMkcol    WebdavMethod = "MKCOL"
 	WebdavMethodPropfind WebdavMethod = "PROPFIND"
 	WebdavMethodPut      WebdavMethod = "PUT"
+	WebdavMethodGet      WebdavMethod = "GET"
 )
 
+// WebDAV XML structures for PROPFIND response
+type Multistatus struct {
+	XMLName   xml.Name   `xml:"multistatus"`
+	Responses []Response `xml:"response"`
+}
+
+type Response struct {
+	Href     string   `xml:"href"`
+	Propstat Propstat `xml:"propstat"`
+}
+
+type Propstat struct {
+	Prop Prop   `xml:"prop"`
+	Status string `xml:"status"`
+}
+
+type Prop struct {
+	ResourceType  ResourceType `xml:"resourcetype"`
+	GetContentLength int64     `xml:"getcontentlength"`
+	GetLastModified  string    `xml:"getlastmodified"`
+	DisplayName      string    `xml:"displayname"`
+}
+
+type ResourceType struct {
+	Collection *struct{} `xml:"collection"`
+}
+
+func (rt ResourceType) IsCollection() bool {
+	return rt.Collection != nil
+}
+
 func NewClient(baseURL, username, password string, httpClient *http.Client) *Client {
 	if !strings.HasSuffix(baseURL, "/") {
 		baseURL += "/"
@@ -131,5 +164,79 @@ func (c *Client) WriteFile(ctx context.Context, remotePath string, content io.Re
 		return nil
 	}
 	return fmt.Errorf("PUT: %s", resp.Status)
-
+}
+
+// ListDir lists files and directories in the given path
+func (c *Client) ListDir(ctx context.Context, dirPath string) ([]Response, error) {
+	dirPath = strings.Trim(dirPath, "/")
+	u, err := url.Parse(c.BaseURL)
+	if err != nil {
+		return nil, err
+	}
+	u.Path = path.Join(u.Path, dirPath)
+	if !strings.HasSuffix(u.Path, "/") {
+		u.Path += "/"
+	}
+
+	resp, err := c.doRequest(ctx, WebdavMethodPropfind, u.String(), nil)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	if resp.StatusCode != http.StatusMultiStatus {
+		return nil, fmt.Errorf("PROPFIND: %s", resp.Status)
+	}
+
+	var multistatus Multistatus
+	if err := xml.NewDecoder(resp.Body).Decode(&multistatus); err != nil {
+		return nil, fmt.Errorf("failed to decode PROPFIND response: %w", err)
+	}
+
+	// Filter out the directory itself from results
+	var results []Response
+	basePath := u.Path
+	for _, r := range multistatus.Responses {
+		decodedHref, err := url.PathUnescape(r.Href)
+		if err != nil {
+			decodedHref = r.Href
+		}
+		// Skip the directory itself
+		if strings.TrimSuffix(decodedHref, "/") == strings.TrimSuffix(basePath, "/") {
+			continue
+		}
+		results = append(results, r)
+	}
+
+	return results, nil
+}
+
+// ReadFile downloads a file and returns a ReadCloser
+func (c *Client) ReadFile(ctx context.Context, filePath string) (io.ReadCloser, int64, error) {
+	filePath = strings.Trim(filePath, "/")
+	u, err := url.Parse(c.BaseURL)
+	if err != nil {
+		return nil, 0, err
+	}
+	u.Path = path.Join(u.Path, filePath)
+
+	req, err := http.NewRequestWithContext(ctx, "GET", u.String(), nil)
+	if err != nil {
+		return nil, 0, err
+	}
+	if c.Username != "" && c.Password != "" {
+		req.SetBasicAuth(c.Username, c.Password)
+	}
+
+	resp, err := c.httpClient.Do(req)
+	if err != nil {
+		return nil, 0, err
+	}
+
+	if resp.StatusCode != http.StatusOK {
+		resp.Body.Close()
+		return nil, 0, fmt.Errorf("GET: %s", resp.Status)
+	}
+
+	return resp.Body, resp.ContentLength, nil
 }

storage/webdav/webdav.go

@@ -5,6 +5,7 @@ import (
 	"fmt"
 	"io"
 	"net/http"
+	"net/url"
 	"path"
 	"strings"
 	"time"
@@ -12,6 +13,7 @@ import (
 	"github.com/charmbracelet/log"
 	config "github.com/krau/SaveAny-Bot/config/storage"
 	storenum "github.com/krau/SaveAny-Bot/pkg/enums/storage"
+	"github.com/krau/SaveAny-Bot/pkg/storagetypes"
 	"github.com/rs/xid"
 )
 
@@ -51,7 +53,7 @@ func (w *Webdav) JoinStoragePath(p string) string {
 
 func (w *Webdav) Save(ctx context.Context, r io.Reader, storagePath string) error {
 	w.logger.Infof("Saving file to %s", storagePath)
-
+	storagePath = w.JoinStoragePath(storagePath)
 	ext := path.Ext(storagePath)
 	base := strings.TrimSuffix(storagePath, ext)
 	candidate := storagePath
@@ -84,3 +86,80 @@ func (w *Webdav) Exists(ctx context.Context, storagePath string) bool {
 	}
 	return exists
 }
+
+// ListFiles implements storage.StorageListable
+func (w *Webdav) ListFiles(ctx context.Context, dirPath string) ([]storagetypes.FileInfo, error) {
+	w.logger.Infof("Listing files in %s", dirPath)
+
+	// Join with base path
+	fullPath := path.Join(w.config.BasePath, dirPath)
+
+	responses, err := w.client.ListDir(ctx, fullPath)
+	if err != nil {
+		w.logger.Errorf("Failed to list directory %s: %v", fullPath, err)
+		return nil, fmt.Errorf("failed to list directory: %w", err)
+	}
+
+	files := make([]storagetypes.FileInfo, 0, len(responses))
+	for _, resp := range responses {
+		// Parse the href to get the file name
+		decodedHref, err := url.PathUnescape(resp.Href)
+		if err != nil {
+			w.logger.Warnf("Failed to unescape href %q: %v; using original value", resp.Href, err)
+			decodedHref = resp.Href
+		}
+
+		// Extract filename from href
+		name := path.Base(strings.TrimSuffix(decodedHref, "/"))
+		if name == "" || name == "." {
+			continue
+		}
+
+		// Parse modification time
+		var modTime time.Time
+		if resp.Propstat.Prop.GetLastModified != "" {
+			// Try RFC1123 format (standard for WebDAV)
+			parsedTime, err := time.Parse(time.RFC1123, resp.Propstat.Prop.GetLastModified)
+			if err != nil {
+				w.logger.Warnf("Failed to parse last modified time %q for %s: %v", resp.Propstat.Prop.GetLastModified, decodedHref, err)
+			} else {
+				modTime = parsedTime
+			}
+		}
+
+		isDir := resp.Propstat.Prop.ResourceType.IsCollection()
+
+		filePath := strings.TrimPrefix(decodedHref, path.Join("/", strings.Trim(path.Dir(fullPath), "/")))
+		filePath = strings.TrimPrefix(filePath, "/")
+
+		fileInfo := storagetypes.FileInfo{
+			Name:    name,
+			Path:    path.Join(dirPath, name),
+			Size:    resp.Propstat.Prop.GetContentLength,
+			IsDir:   isDir,
+			ModTime: modTime,
+		}
+
+		files = append(files, fileInfo)
+	}
+
+	w.logger.Debugf("Found %d files/directories in %s", len(files), dirPath)
+	return files, nil
+}
+
+// OpenFile implements storage.StorageReadable
+func (w *Webdav) OpenFile(ctx context.Context, filePath string) (io.ReadCloser, int64, error) {
+	w.logger.Infof("Opening file %s", filePath)
+
+	// Join with base path
+	fullPath := path.Join(w.config.BasePath, filePath)
+
+	reader, size, err := w.client.ReadFile(ctx, fullPath)
+	if err != nil {
+		w.logger.Errorf("Failed to open file %s: %v", fullPath, err)
+		return nil, 0, fmt.Errorf("failed to open file: %w", err)
+	}
+
+	w.logger.Debugf("Opened file %s (size: %d bytes)", filePath, size)
+	return reader, size, nil
+}