feat: support import files from storages to telegram (#183)

* feat: add import command and batch import functionality - Implemented the `/import` command to allow users to import files from storage to Telegram. - Added support for listing files in storage and filtering based on regex patterns. - Created a batch import task to handle multiple file uploads concurrently. - Introduced progress tracking for batch imports, providing real-time updates to users. - Enhanced storage interfaces to support file listing and reading capabilities. - Updated localization files for the new import command and its usage instructions. - Added utility functions for file size formatting and speed calculation. - Refactored Telegram storage handling to support reading from non-seekable streams. * feat: add i18n for import command * feat: implement ListFiles and OpenFile methods for WebDAV and Alist storage * Update common/i18n/locale/zh-Hans.yaml Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update core/tasks/batchimport/progress.go Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update core/tasks/batchimport/execute.go Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update storage/alist/alist.go Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update common/i18n/locale/en.yaml Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update pkg/storagetypes/fileinfo.go Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update common/i18n/locale/en.yaml Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update core/tasks/batchimport/execute.go Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update storage/webdav/webdav.go Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update storage/telegram/telegram.go Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update core/tasks/batchimport/execute.go Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * Update storage/webdav/webdav.go Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com> * fix: missing progress stats i18n * refactor: use strutil to parse args * chore: update generated code files for consistency --------- Co-authored-by: Copilot <175728472+Copilot@users.noreply.github.com>
2026-06-28 02:31:34 +08:00 · 2026-01-19 17:39:47 +08:00
parent 3e20dc2c5f
commit f92c43b9c8
22 changed files with 1396 additions and 72 deletions
--- a/storage/alist/alist.go
+++ b/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
+}
--- a/storage/alist/types.go
+++ b/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"`
 }
--- a/storage/load.go
+++ b/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)
+}
--- a/storage/local/local.go
+++ b/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 {
@@ -81,3 +82,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
+}
--- a/storage/storage.go
+++ b/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"
@@ -30,6 +31,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
--- a/storage/telegram/split.go
+++ b/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)
--- a/storage/telegram/telegram.go
+++ b/storage/telegram/telegram.go
@@ -92,9 +92,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 +120,96 @@ func (t *Telegram) Save(ctx context.Context, r io.Reader, storagePath string) er
 		}
 		chatID = cid
 	}
-	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()
-	}
+	upler := uploader.NewUploader(tctx.Raw).
+		WithPartSize(tglimit.MaxUploadPartSize).
+		WithThreads(dlutil.BestThreads(size, config.C().Threads))
 	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 {
-		return fmt.Errorf("failed to seek reader: %w", err)
+		if _, err := rs.Seek(0, io.SeekStart); err != nil {
+			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 {
-		file, err = upler.FromReader(ctx, filename, rs)
+	var err error
+	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).
-		MIME(mtype.String())
-
+		ForceFile(forceFile)
+	if mtype != nil {
+		doc = doc.MIME(mtype.String())
+	}
 	var media message.MediaOption = doc
-
-	switch mtypeStr := mtype.String(); {
-	case strings.HasPrefix(mtypeStr, "video/"):
-		media = doc.Video().SupportsStreaming()
-		thumb, err := extractThumbFrame(rs)
-		if err == nil {
-			thumb, err := upler.FromBytes(ctx, "thumb.jpg", thumb)
+	if mtype != nil && rs != nil {
+		switch mtypeStr := mtype.String(); {
+		case strings.HasPrefix(mtypeStr, "video/"):
+			media = doc.Video().SupportsStreaming()
+			thumb, err := extractThumbFrame(rs)
 			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 +220,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 +229,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*")
--- a/storage/webdav/client.go
+++ b/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
 }
--- a/storage/webdav/webdav.go
+++ b/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"
 )

@@ -84,3 +86,77 @@ 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()
+		
+		fileInfo := storagetypes.FileInfo{
+			Name:    name,
+			Path:    strings.TrimPrefix(decodedHref, w.config.BasePath),
+			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
+}