update: xunlei

update: 迅雷使用账密方式登录
2025-11-25 03:15:04 +08:00 · 2025-11-11 01:53:11 +08:00 · 2025-11-11 01:36:33 +08:00 · 2025-11-10 14:29:28 +08:00 · 2025-11-10 10:51:33 +08:00 · 2025-11-07 22:35:06 +08:00
27 changed files with 1990 additions and 583 deletions
--- a/README.md
+++ b/README.md
@@ -39,6 +39,7 @@
 - [服务器要求](https://ecn5khs4t956.feishu.cn/wiki/W8YBww1Mmiu4Cdkp5W4c8pFNnMf?from=from_copylink) 
 - [QQ机器人](https://github.com/ctwj/astrbot_plugin_urldb) 
 - [Telegram机器人](https://ecn5khs4t956.feishu.cn/wiki/SwkQw6AzRiFes7kxJXac3pd2ncb?from=from_copylink)
+- [微信公众号自动回复](https://ecn5khs4t956.feishu.cn/wiki/APOEwOyDYicKGHk7gTzcQKpynkf?from=from_copylink)

 ### v1.3.3
 1. 新增公众号自动回复
--- a/2
+++ b/2
@@ -1 +1 @@
-1.3.3
+1.3.4
--- a/common/xunlei_credentials.go
+++ b/common/xunlei_credentials.go
@@ -0,0 +1,39 @@
+package pan
+
+import "encoding/json"
+
+// XunleiAccountCredentials 迅雷账号凭据结构
+type XunleiAccountCredentials struct {
+	Username     string `json:"username"`     // 手机号（不包含+86前缀）
+	Password     string `json:"password"`     // 密码
+	RefreshToken string `json:"refresh_token"` // 当前有效的refresh_token
+}
+
+// ParseCredentialsFromCk 从ck字段解析账号凭据
+func ParseCredentialsFromCk(ck string) (*XunleiAccountCredentials, error) {
+	var credentials XunleiAccountCredentials
+	if err := json.Unmarshal([]byte(ck), &credentials); err != nil {
+		return nil, err
+	}
+	return &credentials, nil
+}
+
+// IsAccountCredentials 检查ck是否包含账号密码信息
+func IsAccountCredentials(ck string) bool {
+	var credentials map[string]interface{}
+	if err := json.Unmarshal([]byte(ck), &credentials); err != nil {
+		return false
+	}
+	_, hasUsername := credentials["username"]
+	_, hasPassword := credentials["password"]
+	return hasUsername && hasPassword
+}
+
+// ToJsonString 转换为JSON字符串
+func (c *XunleiAccountCredentials) ToJsonString() (string, error) {
+	data, err := json.Marshal(c)
+	if err != nil {
+		return "", err
+	}
+	return string(data), nil
+}
--- a/common/xunlei_login.go
+++ b/common/xunlei_login.go
@@ -0,0 +1,232 @@
+package pan
+
+import (
+	"bytes"
+	"crypto/md5"
+	"encoding/hex"
+	"encoding/json"
+	"fmt"
+	"io/ioutil"
+	"log"
+	"net/http"
+	"strings"
+	"time"
+)
+
+// 新增常量定义
+const (
+	XLUSER_CLIENT_ID = "XW5SkOhLDjnOZP7J" // 登录
+	PAN_CLIENT_ID    = "Xqp0kJBXWhwaTpB6" // 获取文件列表
+	CLIENT_SECRET    = "Og9Vr1L8Ee6bh0olFxFDRg"
+	CLIENT_VERSION   = "1.92.9" // 更新为与xunlei_3项目相同的版本
+	PACKAG_ENAME     = "pan.xunlei.com"
+)
+
+var SALTS = []string{
+	"QG3/GhopO+5+T",
+	"1Sv94+ANND3lDmmw",
+	"q2eTxRva8b3B5d",
+	"m2",
+	"VIc5CZRBMU71ENfbOh0+RgWIuzLy",
+	"66M8Wpw6nkBEekOtL6e",
+	"N0rucK7S8W/vrRkfPto5urIJJS8dVY0S",
+	"oLAR7pdUVUAp9xcuHWzrU057aUhdCJrt",
+	"6lxcykBSsfI//GR9",
+	"r50cz+1I4gbU/fk8",
+	"tdwzrTc4SNFC4marNGTgf05flC85A",
+	"qvNVUDFjfsOMqvdi2gB8gCvtaJAIqxXs",
+}
+
+// captchaSign 生成验证码签名 - 完全复制自xunlei_3项目
+func (x *XunleiPanService) captchaSign(clientId string, deviceID string, timestamp string) string {
+	sign := clientId + CLIENT_VERSION + PACKAG_ENAME + deviceID + timestamp
+	log.Printf("urldb 签名基础字符串: %s", sign)
+	for _, salt := range SALTS { // salt =
+		hash := md5.Sum([]byte(sign + salt))
+		sign = hex.EncodeToString(hash[:])
+	}
+	log.Printf("urldb 最终签名: 1.%s", sign)
+	return fmt.Sprintf("1.%s", sign)
+}
+
+// getTimestamp 获取当前时间戳
+func (x *XunleiPanService) getTimestamp() int64 {
+	return time.Now().UnixMilli()
+}
+
+// LoginWithCredentials 使用账号密码登录
+func (x *XunleiPanService) LoginWithCredentials(username, password string) (XunleiTokenData, error) {
+	loginURL := "https://xluser-ssl.xunlei.com/v1/auth/signin"
+
+	// 初始化验证码 - 完全模仿xunlei_3的CaptchaInit方法
+	captchaURL := "https://xluser-ssl.xunlei.com/v1/shield/captcha/init"
+
+	// 构造meta参数（完全模仿xunlei_3，只包含phone_number）
+	meta := map[string]interface{}{
+		"phone_number": "+86" + username,
+	}
+
+	// 构造验证码请求（完全模仿xunlei_3）
+	captchaBody := map[string]interface{}{
+		"client_id": XLUSER_CLIENT_ID,
+		"action":    "POST:/v1/auth/signin",
+		"device_id": x.deviceId,
+		"meta":      meta,
+	}
+
+	log.Printf("发送验证码初始化请求: %+v", captchaBody)
+	resp, err := x.sendCaptchaRequest(captchaURL, captchaBody)
+	if err != nil {
+		return XunleiTokenData{}, fmt.Errorf("获取验证码失败: %v", err)
+	}
+
+	if resp["captcha_token"] == nil {
+		return XunleiTokenData{}, fmt.Errorf("获取验证码失败: 响应中没有captcha_token")
+	}
+
+	captchaToken, ok := resp["captcha_token"].(string)
+	if !ok {
+		return XunleiTokenData{}, fmt.Errorf("获取验证码失败: captcha_token格式错误")
+	}
+	log.Printf("成功获取captcha_token: %s", captchaToken)
+
+	// 构造登录请求数据
+	loginData := map[string]interface{}{
+		"client_id":     XLUSER_CLIENT_ID,
+		"client_secret": CLIENT_SECRET,
+		"password":      password,
+		"username":      "+86 " + username,
+		"captcha_token": captchaToken,
+	}
+
+	// 发送登录请求
+	userInfo, err := x.sendCaptchaRequest(loginURL, loginData)
+	if err != nil {
+		return XunleiTokenData{}, fmt.Errorf("登录请求失败: %v", err)
+	}
+
+	// 提取token信息
+	accessToken, ok := userInfo["access_token"].(string)
+	if !ok {
+		return XunleiTokenData{}, fmt.Errorf("登录响应中没有access_token")
+	}
+
+	refreshToken, ok := userInfo["refresh_token"].(string)
+	if !ok {
+		return XunleiTokenData{}, fmt.Errorf("登录响应中没有refresh_token")
+	}
+
+	sub, ok := userInfo["sub"].(string)
+	if !ok {
+		sub = ""
+	}
+
+	// 计算过期时间
+	expiresIn := int64(3600) // 默认1小时
+	if exp, ok := userInfo["expires_in"].(float64); ok {
+		expiresIn = int64(exp)
+	}
+	expiresAt := time.Now().Unix() + expiresIn - 60 // 减去60秒缓冲
+
+	log.Printf("登录成功，获取到token")
+	return XunleiTokenData{
+		AccessToken:  accessToken,
+		RefreshToken: refreshToken,
+		ExpiresIn:    expiresIn,
+		ExpiresAt:    expiresAt,
+		Sub:          sub,
+		TokenType:    "Bearer",
+		UserId:       sub,
+	}, nil
+}
+
+// sendCaptchaRequest 发送验证码请求 - 完全复制xunlei_3的sendRequest实现
+func (x *XunleiPanService) sendCaptchaRequest(url string, data map[string]interface{}) (map[string]interface{}, error) {
+	jsonData, err := json.Marshal(data)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Printf("发送验证码请求URL: %s", url)
+	log.Printf("发送验证码请求数据: %s", string(jsonData))
+
+	req, err := http.NewRequest("POST", url, bytes.NewBuffer(jsonData))
+	if err != nil {
+		return nil, err
+	}
+
+	// 完全复制xunlei_3的请求头设置
+	reqHeaders := x.getHeadersForRequest(nil)
+	// 添加特定的headers
+	reqHeaders["Content-Type"] = "application/x-www-form-urlencoded"
+	reqHeaders["User-Agent"] = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36"
+
+	for k, v := range reqHeaders {
+		req.Header.Set(k, v)
+	}
+
+	// 根据URL确定使用哪个client_id
+	if strings.Contains(url, "shield/captcha/init") {
+		// 对于验证码初始化，如果数据中指定了client_id，则使用该client_id
+		if clientID, ok := data["client_id"].(string); ok {
+			req.Header.Set("X-Client-Id", clientID)
+		} else {
+			// 默认使用PAN_CLIENT_ID用于API相关的验证码
+			req.Header.Set("X-Client-Id", PAN_CLIENT_ID)
+		}
+	} else if strings.Contains(url, "auth/") {
+		// 对于认证相关的请求，使用登录相关的client_id
+		req.Header.Set("X-Client-Id", XLUSER_CLIENT_ID)
+	} else {
+		// 对于一般的API请求，使用PAN_CLIENT_ID
+		req.Header.Set("X-Client-Id", PAN_CLIENT_ID)
+	}
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Printf("验证码响应状态码: %d", resp.StatusCode)
+	log.Printf("验证码响应内容: %s", string(body))
+
+	var result map[string]interface{}
+	if err := json.Unmarshal(body, &result); err != nil {
+		return nil, fmt.Errorf("JSON 解析失败: %v, raw: %s", err, string(body))
+	}
+
+	log.Printf("解析后的响应: %+v", result)
+	return result, nil
+}
+
+// getHeadersForRequest 获取请求头
+func (x *XunleiPanService) getHeadersForRequest(accessToken *string) map[string]string {
+	headers := map[string]string{
+		"Content-Type": "application/json; charset=utf-8",
+	}
+
+	// 这里我们简化处理，因为验证码请求不需要这些
+	// if x.CaptchaToken != nil {
+	// 	headers["User-Agent"] = x.buildCustomUserAgent()
+	// 	headers["X-Captcha-Token"] = *x.CaptchaToken
+	// } else {
+	headers["User-Agent"] = "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/126.0.0.0 Safari/537.36"
+	// }
+
+	// if accessToken != nil {
+	// 	headers["Authorization"] = fmt.Sprintf("Bearer %s", *accessToken)
+	// }
+
+	// if x.DeviceID != "" {
+	// 	headers["X-Device-Id"] = x.DeviceID
+	// }
+
+	return headers
+}
--- a/common/xunlei_pan.bak
+++ b/common/xunlei_pan.bak
@@ -0,0 +1,897 @@
+package pan
+
+import (
+	"encoding/json"
+	"fmt"
+	"log"
+	"net/http"
+	"strconv"
+	"strings"
+	"sync"
+	"time"
+
+	"github.com/ctwj/urldb/db/entity"
+	"github.com/ctwj/urldb/db/repo"
+)
+
+// CaptchaData 存储在数据库中的验证码令牌数据
+type CaptchaData struct {
+	CaptchaToken string `json:"captcha_token"`
+	ExpiresAt    int64  `json:"expires_at"`
+}
+
+// XunleiExtraData 所有额外数据的容器
+type XunleiTokenData struct {
+	AccessToken  string `json:"access_token"`
+	RefreshToken string `json:"refresh_token"`
+	ExpiresIn    int64  `json:"expires_in"`
+	ExpiresAt    int64  `json:"expires_at"`
+	Sub          string `json:"sub"`
+	TokenType    string `json:"token_type"`
+	UserId       string `json:"user_id"`
+}
+
+type XunleiExtraData struct {
+	Captcha *CaptchaData
+	Token   *XunleiTokenData
+}
+
+type XunleiPanService struct {
+	*BasePanService
+	configMutex sync.RWMutex
+	clientId    string
+	deviceId    string
+	entity      entity.Cks
+	cksRepo     repo.CksRepository
+	extra       XunleiExtraData // 需要保存到数据库的token信息
+}
+
+// 配置化 API Host
+func (x *XunleiPanService) apiHost(apiType string) string {
+	if apiType == "user" {
+		return "https://xluser-ssl.xunlei.com"
+	}
+	return "https://api-pan.xunlei.com"
+}
+
+func (x *XunleiPanService) setCommonHeader(req *http.Request) {
+	for k, v := range x.headers {
+		req.Header.Set(k, v)
+	}
+}
+
+// NewXunleiPanService 创建迅雷网盘服务
+func NewXunleiPanService(config *PanConfig) *XunleiPanService {
+	xunleiInstance := &XunleiPanService{
+		BasePanService: NewBasePanService(config),
+		clientId:       "Xqp0kJBXWhwaTpB6",
+		deviceId:       "925b7631473a13716b791d7f28289cad",
+		extra:          XunleiExtraData{}, // Initialize extra with zero values
+	}
+	xunleiInstance.SetHeaders(map[string]string{
+		"Accept":             "*/;",
+		"Accept-Encoding":    "deflate",
+		"Accept-Language":    "zh-CN,zh;q=0.9",
+		"Cache-Control":      "no-cache",
+		"Content-Type":       "application/json",
+		"Origin":             "https://pan.xunlei.com",
+		"Pragma":             "no-cache",
+		"Priority":           "u=1,i",
+		"Referer":            "https://pan.xunlei.com/",
+		"sec-ch-ua":          `"Not;A=Brand";v="99", "Google Chrome";v="139", "Chromium";v="139"`,
+		"sec-ch-ua-mobile":   "?0",
+		"sec-ch-ua-platform": `"Windows"`,
+		"sec-fetch-dest":     "empty",
+		"sec-fetch-mode":     "cors",
+		"sec-fetch-site":     "same-site",
+		"User-Agent":         "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/139.0.0.0 Safari/537.36",
+		"Authorization":      "",
+		"x-captcha-token":    "",
+		"x-client-id":        xunleiInstance.clientId,
+		"x-device-id":        xunleiInstance.deviceId,
+	})
+
+	xunleiInstance.UpdateConfig(config)
+	return xunleiInstance
+}
+
+// SetCKSRepository 设置 CksRepository 和 entity
+func (x *XunleiPanService) SetCKSRepository(cksRepo repo.CksRepository, entity entity.Cks) {
+	x.cksRepo = cksRepo
+	x.entity = entity
+	var extra XunleiExtraData
+	if err := json.Unmarshal([]byte(x.entity.Extra), &extra); err != nil {
+		log.Printf("解析 extra 数据失败: %v，使用空数据", err)
+	}
+	x.extra = extra
+}
+
+// GetXunleiInstance 获取迅雷网盘服务单例实例
+func GetXunleiInstance() *XunleiPanService {
+	return NewXunleiPanService(nil)
+}
+
+func (x *XunleiPanService) GetAccessTokenByRefreshToken(refreshToken string) (XunleiTokenData, error) {
+	// 构造请求体
+	body := map[string]interface{}{
+		"client_id":     x.clientId,
+		"grant_type":    "refresh_token",
+		"refresh_token": refreshToken,
+	}
+
+	// 过滤 headers（移除 Authorization 和 x-captcha-token）
+	filteredHeaders := make(map[string]string)
+	for k, v := range x.headers {
+		if k != "Authorization" && k != "x-captcha-token" {
+			filteredHeaders[k] = v
+		}
+	}
+
+	// 调用 API 获取新的 token
+	resp, err := x.requestXunleiApi("https://xluser-ssl.xunlei.com/v1/auth/token", "POST", body, nil, filteredHeaders)
+	if err != nil {
+		return XunleiTokenData{}, fmt.Errorf("获取 access_token 请求失败: %v", err)
+	}
+
+	// 正确做法：用 exists 判断
+	if _, exists := resp["access_token"]; exists {
+		// 会输出，即使值为 nil
+	} else {
+		return XunleiTokenData{}, fmt.Errorf("获取 access_token 请求失败: %v 不存在", "access_token")
+	}
+
+	// 计算过期时间（当前时间 + expires_in - 60 秒缓冲）
+	currentTime := time.Now().Unix()
+	expiresAt := currentTime + int64(resp["expires_in"].(float64)) - 60
+	resp["expires_at"] = expiresAt
+	jsonBytes, _ := json.Marshal(resp)
+
+	var result XunleiTokenData
+	json.Unmarshal(jsonBytes, &result)
+	return result, nil
+}
+
+// getAccessToken 获取 Access Token（内部包含缓存判断、刷新、保存）- 匹配 PHP 版本
+func (x *XunleiPanService) getAccessToken() (string, error) {
+	// 检查 Access Token 是否有效
+	currentTime := time.Now().Unix()
+	if x.extra.Token != nil && x.extra.Token.AccessToken != "" && x.extra.Token.ExpiresAt > currentTime {
+		return x.extra.Token.AccessToken, nil
+	}
+	newData, err := x.GetAccessTokenByRefreshToken(x.extra.Token.RefreshToken)
+	if err != nil {
+		return "", fmt.Errorf("获取 access_token 失败: %v", err)
+	}
+
+	x.extra.Token.AccessToken = newData.AccessToken
+	x.extra.Token.ExpiresAt = newData.ExpiresAt
+
+	// 保存到数据库
+	extraBytes, err := json.Marshal(x.extra)
+	if err != nil {
+		return "", fmt.Errorf("序列化 extra 数据失败: %v", err)
+	}
+	x.entity.Extra = string(extraBytes)
+	if err := x.cksRepo.UpdateWithAllFields(&x.entity); err != nil {
+		return "", fmt.Errorf("保存 access_token 到数据库失败: %v", err)
+	}
+	return newData.AccessToken, nil
+}
+
+// getCaptchaToken 获取 captcha_token - 匹配 PHP 版本
+func (x *XunleiPanService) getCaptchaToken() (string, error) {
+	// 检查 Captcha Token 是否有效
+	currentTime := time.Now().Unix()
+	if x.extra.Captcha != nil && x.extra.Captcha.CaptchaToken != "" && x.extra.Captcha.ExpiresAt > currentTime {
+		return x.extra.Captcha.CaptchaToken, nil
+	}
+
+	// 构造请求体
+	body := map[string]interface{}{
+		"client_id": x.clientId,
+		"action":    "get:/drive/v1/share",
+		"device_id": x.deviceId,
+		"meta": map[string]interface{}{
+			"username":       "",
+			"phone_number":   "",
+			"email":          "",
+			"package_name":   "pan.xunlei.com",
+			"client_version": "1.45.0",
+			"captcha_sign":   "1.fe2108ad808a74c9ac0243309242726c",
+			"timestamp":      "1645241033384",
+			"user_id":        "0",
+		},
+	}
+
+	captchaHeaders := map[string]string{
+		"Content-Type": "application/json",
+		"User-Agent":   "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36",
+	}
+
+	// 调用 API 获取 captcha_token
+	resp, err := x.requestXunleiApi("https://xluser-ssl.xunlei.com/v1/shield/captcha/init", "POST", body, nil, captchaHeaders)
+	if err != nil {
+		return "", fmt.Errorf("获取 captcha_token 请求失败: %v", err)
+	}
+
+	if resp["captcha_token"] != nil && resp["captcha_token"] != "" {
+		//
+	} else {
+		return "", fmt.Errorf("获取 captcha_token 失败: %v", resp)
+	}
+
+	// 计算过期时间（当前时间 + expires_in - 10 秒缓冲）
+	expiresAt := currentTime + int64(resp["expires_in"].(float64)) - 10
+
+	// 更新 extra 数据
+	if x.extra.Captcha == nil {
+		x.extra.Captcha = &CaptchaData{}
+	}
+	x.extra.Captcha.CaptchaToken = resp["captcha_token"].(string)
+	x.extra.Captcha.ExpiresAt = expiresAt
+
+	// 保存到数据库
+	extraBytes, err := json.Marshal(x.extra)
+	if err != nil {
+		return "", fmt.Errorf("序列化 extra 数据失败: %v", err)
+	}
+	x.entity.Extra = string(extraBytes)
+	if err := x.cksRepo.UpdateWithAllFields(&x.entity); err != nil {
+		return "", fmt.Errorf("保存 captcha_token 到数据库失败: %v", err)
+	}
+
+	return resp["captcha_token"].(string), nil
+}
+
+// requestXunleiApi 迅雷 API 通用请求方法 - 使用 BasePanService 方法
+func (x *XunleiPanService) requestXunleiApi(url string, method string, data map[string]interface{}, queryParams map[string]string, headers map[string]string) (map[string]interface{}, error) {
+	var respData []byte
+	var err error
+
+	// 先更新当前请求的 headers
+	originalHeaders := make(map[string]string)
+	for k, v := range x.headers {
+		originalHeaders[k] = v
+	}
+
+	// 临时设置请求的 headers
+	for k, v := range headers {
+		x.SetHeader(k, v)
+	}
+	defer func() {
+		// 恢复原始 headers
+		for k, v := range originalHeaders {
+			x.SetHeader(k, v)
+		}
+	}()
+
+	// 根据方法调用相应的 BasePanService 方法
+	if method == "GET" {
+		respData, err = x.HTTPGet(url, queryParams)
+	} else if method == "POST" {
+		respData, err = x.HTTPPost(url, data, queryParams)
+	} else {
+		return nil, fmt.Errorf("不支持的HTTP方法: %s", method)
+	}
+
+	if err != nil {
+		return nil, err
+	}
+
+	var result map[string]interface{}
+	if err := json.Unmarshal(respData, &result); err != nil {
+		return nil, fmt.Errorf("JSON 解析失败: %v, raw: %s", err, string(respData))
+	}
+
+	return result, nil
+}
+
+func (x *XunleiPanService) UpdateConfig(config *PanConfig) {
+	if config == nil {
+		return
+	}
+	x.configMutex.Lock()
+	defer x.configMutex.Unlock()
+	x.config = config
+	if config.Cookie != "" {
+		x.SetHeader("Cookie", config.Cookie)
+	}
+}
+
+// GetServiceType 获取服务类型
+func (x *XunleiPanService) GetServiceType() ServiceType {
+	return Xunlei
+}
+
+func extractCode(url string) string {
+	// 查找 pwd= 的位置
+	if pwdIndex := strings.Index(url, "pwd="); pwdIndex != -1 {
+		code := url[pwdIndex+4:]
+		// 移除 # 及后面的内容（如果存在）
+		if hashIndex := strings.Index(code, "#"); hashIndex != -1 {
+			code = code[:hashIndex]
+		}
+		return code
+	}
+	return ""
+}
+
+// Transfer 转存分享链接 - 实现 PanService 接口，匹配 XunleiPan.php 的逻辑
+func (x *XunleiPanService) Transfer(shareID string) (*TransferResult, error) {
+	// 读取配置（线程安全）
+	x.configMutex.RLock()
+	config := x.config
+	x.configMutex.RUnlock()
+
+	log.Printf("开始处理迅雷分享: %s", shareID)
+
+	// 1️⃣ 获取 AccessToken 和 CaptchaToken
+	accessToken, err := x.getAccessToken()
+	if err != nil {
+		return ErrorResult(fmt.Sprintf("获取accessToken失败: %v", err)), nil
+	}
+
+	captchaToken, err := x.getCaptchaToken()
+	if err != nil {
+		return ErrorResult(fmt.Sprintf("获取captchaToken失败: %v", err)), nil
+	}
+
+	// 转存模式：实现完整的转存流程
+	thisCode := extractCode(config.URL)
+
+	// 获取分享详情
+	shareDetail, err := x.getShare(shareID, thisCode, accessToken, captchaToken)
+	if err != nil {
+		return ErrorResult(fmt.Sprintf("获取分享详情失败: %v", err)), nil
+	}
+	if shareDetail["share_status"].(string) != "OK" {
+		return ErrorResult(fmt.Sprintf("获取分享详情失败: %v", "分享状态异常")), nil
+	}
+	if shareDetail["file_num"].(string) == "0" {
+		return ErrorResult(fmt.Sprintf("获取分享详情失败: %v", "文件列表为空")), nil
+	}
+
+	parent_id := "" // 默认存储路径
+
+	// 检查是否为检验模式
+	if config.IsType == 1 {
+		// 检验模式：直接获取分享信息
+		urls := map[string]interface{}{
+			"title":     shareDetail["title"],
+			"share_url": config.URL,
+			"stoken":    "",
+		}
+		return SuccessResult("检验成功", urls), nil
+	}
+
+	// files := shareDetail["files"].([]interface{})
+	// fileIDs := make([]string, 0)
+	// for _, file := range files {
+	// 	fileMap := file.(map[string]interface{})
+	// 	if fid, ok := fileMap["id"].(string); ok {
+	// 		fileIDs = append(fileIDs, fid)
+	// 	}
+	// }
+
+	// 处理广告过滤（这里简化处理）
+	// TODO: 添加广告文件过滤逻辑
+
+	// 转存资源
+	restoreResult, err := x.getRestore(shareID, shareDetail, accessToken, captchaToken, parent_id)
+	if err != nil {
+		return ErrorResult(fmt.Sprintf("转存失败: %v", err)), nil
+	}
+
+	// 获取转存任务信息
+	taskID := restoreResult["restore_task_id"].(string)
+
+	// 等待转存完成
+	taskResp, err := x.waitForTask(taskID, accessToken, captchaToken)
+	if err != nil {
+		return ErrorResult(fmt.Sprintf("等待转存完成失败: %v", err)), nil
+	}
+
+	// 获取任务结果以获取文件ID
+	existingFileIds := make([]string, 0)
+	if params, ok2 := taskResp["params"].(map[string]interface{}); ok2 {
+		if traceIds, ok3 := params["trace_file_ids"].(string); ok3 {
+			traceData := make(map[string]interface{})
+			json.Unmarshal([]byte(traceIds), &traceData)
+			for _, fid := range traceData {
+				existingFileIds = append(existingFileIds, fid.(string))
+			}
+		}
+	}
+
+	// 创建分享链接
+	expirationDays := "-1"
+	if config.ExpiredType == 2 {
+		expirationDays = "2"
+	}
+
+	// 根据share_id获取到分享链接
+	shareResult, err := x.getSharePassword(existingFileIds, accessToken, captchaToken, expirationDays)
+	if err != nil {
+		return ErrorResult(fmt.Sprintf("创建分享链接失败: %v", err)), nil
+	}
+
+	var fid string
+	if len(existingFileIds) > 1 {
+		fid = strings.Join(existingFileIds, ",")
+	} else {
+		fid = existingFileIds[0]
+	}
+
+	result := map[string]interface{}{
+		"title":    "",
+		"shareUrl": shareResult["share_url"].(string) + "?pwd=" + shareResult["pass_code"].(string),
+		"code":     shareResult["pass_code"].(string),
+		"fid":      fid,
+	}
+
+	return SuccessResult("转存成功", result), nil
+}
+
+// waitForTask 等待任务完成 - 使用 HTTPGet 方法
+func (x *XunleiPanService) waitForTask(taskID string, accessToken, captchaToken string) (map[string]interface{}, error) {
+	maxRetries := 50
+	retryDelay := 2 * time.Second
+
+	for retryIndex := 0; retryIndex < maxRetries; retryIndex++ {
+		result, err := x.getTaskStatus(taskID, retryIndex, accessToken, captchaToken)
+		if err != nil {
+			return nil, err
+		}
+
+		if int64(result["progress"].(float64)) == 100 { // 任务完成
+			return result, nil
+		}
+
+		time.Sleep(retryDelay)
+	}
+
+	return nil, fmt.Errorf("任务超时")
+}
+
+// getTaskStatus 获取任务状态 - 使用 HTTPGet 方法
+func (x *XunleiPanService) getTaskStatus(taskID string, retryIndex int, accessToken, captchaToken string) (map[string]interface{}, error) {
+	apiURL := x.apiHost("") + "/drive/v1/tasks/" + taskID
+	queryParams := map[string]string{}
+
+	// 设置 request 所需的 headers
+	headers := map[string]string{
+		"Authorization":   "Bearer " + accessToken,
+		"x-captcha-token": captchaToken,
+	}
+
+	resp, err := x.requestXunleiApi(apiURL, "GET", nil, queryParams, headers)
+	if err != nil {
+		return nil, err
+	}
+	return resp, nil
+}
+
+// GetUserInfoByEntity 根据 entity.Cks 获取用户信息（待实现）
+func (x *XunleiPanService) GetUserInfoByEntity(cks entity.Cks) (*UserInfo, error) {
+	return nil, nil
+}
+
+// getShare 获取分享详情 - 匹配 PHP 版本
+func (x *XunleiPanService) getShare(shareID, passCode, accessToken, captchaToken string) (map[string]interface{}, error) {
+	// 设置 headers
+	headers := make(map[string]string)
+	for k, v := range x.headers {
+		headers[k] = v
+	}
+	headers["Authorization"] = "Bearer " + accessToken
+	headers["x-captcha-token"] = captchaToken
+
+	queryParams := map[string]string{
+		"share_id":        shareID,
+		"pass_code":       passCode,
+		"limit":           "100",
+		"pass_code_token": "",
+		"page_token":      "",
+		"thumbnail_size":  "SIZE_SMALL",
+	}
+
+	return x.requestXunleiApi("https://api-pan.xunlei.com/drive/v1/share", "GET", nil, queryParams, headers)
+}
+
+// getRestore 转存到网盘 - 匹配 PHP 版本
+func (x *XunleiPanService) getRestore(shareID string, infoData map[string]interface{}, accessToken, captchaToken, parentID string) (map[string]interface{}, error) {
+	ids := make([]string, 0)
+	if files, ok := infoData["files"].([]interface{}); ok {
+		for _, file := range files {
+			if fileMap, ok2 := file.(map[string]interface{}); ok2 {
+				if id, ok3 := fileMap["id"].(string); ok3 {
+					ids = append(ids, id)
+				}
+			}
+		}
+	}
+
+	passCodeToken := ""
+	if token, ok := infoData["pass_code_token"]; ok {
+		if tokenStr, ok2 := token.(string); ok2 {
+			passCodeToken = tokenStr
+		}
+	}
+
+	data := map[string]interface{}{
+		"parent_id":         parentID,
+		"share_id":          shareID,
+		"pass_code_token":   passCodeToken,
+		"ancestor_ids":      []string{},
+		"specify_parent_id": true,
+		"file_ids":          ids,
+	}
+
+	headers := make(map[string]string)
+	for k, v := range x.headers {
+		headers[k] = v
+	}
+	headers["Authorization"] = "Bearer " + accessToken
+	headers["x-captcha-token"] = captchaToken
+
+	return x.requestXunleiApi("https://api-pan.xunlei.com/drive/v1/share/restore", "POST", data, nil, headers)
+}
+
+// getTasks 获取转存任务状态 - 匹配 PHP 版本
+func (x *XunleiPanService) getTasks(taskID, accessToken, captchaToken string) (map[string]interface{}, error) {
+	headers := make(map[string]string)
+	for k, v := range x.headers {
+		headers[k] = v
+	}
+	headers["Authorization"] = "Bearer " + accessToken
+	headers["x-captcha-token"] = captchaToken
+
+	return x.requestXunleiApi("https://api-pan.xunlei.com/drive/v1/tasks/"+taskID, "GET", nil, nil, headers)
+}
+
+// getSharePassword 创建分享链接 - 匹配 PHP 版本
+func (x *XunleiPanService) getSharePassword(fileIDs []string, accessToken, captchaToken, expirationDays string) (map[string]interface{}, error) {
+	data := map[string]interface{}{
+		"file_ids": fileIDs,
+		"share_to": "copy",
+		"params": map[string]interface{}{
+			"subscribe_push":     "false",
+			"WithPassCodeInLink": "true",
+		},
+		"title":           "云盘资源分享",
+		"restore_limit":   "-1",
+		"expiration_days": expirationDays,
+	}
+
+	headers := make(map[string]string)
+	for k, v := range x.headers {
+		headers[k] = v
+	}
+	headers["Authorization"] = "Bearer " + accessToken
+	headers["x-captcha-token"] = captchaToken
+
+	return x.requestXunleiApi("https://api-pan.xunlei.com/drive/v1/share", "POST", data, nil, headers)
+}
+
+// getShareInfo 获取分享信息（用于检验模式）
+func (x *XunleiPanService) getShareInfo(shareID string) (*XLShareInfo, error) {
+	// 使用现有的 GetShareFolder 方法获取分享信息
+	shareDetail, err := x.GetShareFolder(shareID, "", "")
+	if err != nil {
+		return nil, err
+	}
+
+	// 构造分享信息
+	shareInfo := &XLShareInfo{
+		ShareID: shareID,
+		Title:   fmt.Sprintf("迅雷分享_%s", shareID),
+		Files:   make([]XLFileInfo, 0),
+	}
+
+	// 处理文件信息
+	for _, file := range shareDetail.Data.Files {
+		shareInfo.Files = append(shareInfo.Files, XLFileInfo{
+			FileID: file.FileID,
+			Name:   file.Name,
+		})
+	}
+
+	return shareInfo, nil
+}
+
+// GetFiles 获取文件列表 - 匹配 PHP 版本接口调用
+func (x *XunleiPanService) GetFiles(pdirFid string) (*TransferResult, error) {
+	log.Printf("开始获取迅雷网盘文件列表，目录ID: %s", pdirFid)
+
+	// 获取 tokens
+	accessToken, err := x.getAccessToken()
+	if err != nil {
+		return ErrorResult(fmt.Sprintf("获取accessToken失败: %v", err)), nil
+	}
+
+	captchaToken, err := x.getCaptchaToken()
+	if err != nil {
+		return ErrorResult(fmt.Sprintf("获取captchaToken失败: %v", err)), nil
+	}
+
+	// 设置 headers
+	headers := make(map[string]string)
+	for k, v := range x.headers {
+		headers[k] = v
+	}
+	headers["Authorization"] = "Bearer " + accessToken
+	headers["x-captcha-token"] = captchaToken
+
+	filters := map[string]interface{}{
+		"phase": map[string]interface{}{
+			"eq": "PHASE_TYPE_COMPLETE",
+		},
+		"trashed": map[string]interface{}{
+			"eq": false,
+		},
+	}
+
+	filtersStr, _ := json.Marshal(filters)
+	queryParams := map[string]string{
+		"parent_id":      pdirFid,
+		"filters":        string(filtersStr),
+		"with_audit":     "true",
+		"thumbnail_size": "SIZE_SMALL",
+		"limit":          "50",
+	}
+
+	result, err := x.requestXunleiApi("https://api-pan.xunlei.com/drive/v1/files", "GET", nil, queryParams, headers)
+	if err != nil {
+		return ErrorResult(fmt.Sprintf("获取文件列表失败: %v", err)), nil
+	}
+
+	if code, ok := result["code"].(float64); ok && code != 0 {
+		return ErrorResult("获取文件列表失败"), nil
+	}
+
+	if data, ok := result["data"].(map[string]interface{}); ok {
+		if files, ok2 := data["files"]; ok2 {
+			return SuccessResult("获取成功", files), nil
+		}
+	}
+
+	return SuccessResult("获取成功", []interface{}{}), nil
+}
+
+// DeleteFiles 删除文件 - 实现 PanService 接口
+func (x *XunleiPanService) DeleteFiles(fileList []string) (*TransferResult, error) {
+	log.Printf("开始删除迅雷网盘文件，文件数量: %d", len(fileList))
+
+	// 使用现有的 ShareBatchDelete 方法删除分享
+	result, err := x.ShareBatchDelete(fileList)
+	if err != nil {
+		return ErrorResult(fmt.Sprintf("删除文件失败: %v", err)), nil
+	}
+
+	if result.Code != 0 {
+		return ErrorResult(fmt.Sprintf("删除文件失败: %s", result.Msg)), nil
+	}
+
+	return SuccessResult("删除成功", nil), nil
+}
+
+// GetUserInfo 获取用户信息 - 实现 PanService 接口，cookie 参数为 refresh_token，先获取 access_token 再访问 API
+func (x *XunleiPanService) GetUserInfo(cookie *string) (*UserInfo, error) {
+	userInfo := &UserInfo{}
+	accessToken, err := x.getAccessToken()
+	if err != nil {
+		return nil, err
+	}
+
+	captchaToken, err := x.getCaptchaToken()
+	if err != nil {
+		return nil, err
+	}
+
+	headers := make(map[string]string)
+	for k, v := range x.headers {
+		headers[k] = v
+	}
+	headers["Authorization"] = "Bearer " + accessToken
+	headers["x-captcha-token"] = captchaToken
+
+	resp, err := x.requestXunleiApi("https://api-pan.xunlei.com/drive/v1/about", "GET", nil, nil, headers)
+	if err != nil {
+		return nil, fmt.Errorf("获取用户信息失败: %v", err)
+	}
+	limit := resp["quota"].(map[string]interface{})["limit"].(string)
+	limitInt, _ := strconv.ParseInt(limit, 10, 64)
+	used := resp["quota"].(map[string]interface{})["usage"].(string)
+	usedInt, _ := strconv.ParseInt(used, 10, 64)
+	userInfo.TotalSpace = limitInt
+	userInfo.UsedSpace = usedInt
+
+	// 获取用户信息
+	respData, err := x.requestXunleiApi(x.apiHost("user")+"/v1/user/me", "GET", nil, nil, headers)
+	if err != nil {
+		return nil, fmt.Errorf("获取用户信息失败: %v", err)
+	}
+
+	vipInfo := respData["vip_info"].([]interface{})
+	isVip := vipInfo[0].(map[string]interface{})["is_vip"].(string) != "0"
+
+	userInfo.Username = respData["name"].(string)
+	userInfo.ServiceType = x.GetServiceType().String()
+	userInfo.VIPStatus = isVip
+	return userInfo, nil
+}
+
+// GetShareList 严格对齐 GET + query（使用 BasePanService）
+func (x *XunleiPanService) GetShareList(pageToken string) (*XLShareListResp, error) {
+	api := x.apiHost("") + "/drive/v1/share/list"
+	queryParams := map[string]string{
+		"limit":          "100",
+		"thumbnail_size": "SIZE_SMALL",
+	}
+	if pageToken != "" {
+		queryParams["page_token"] = pageToken
+	}
+
+	respData, err := x.HTTPGet(api, queryParams)
+	if err != nil {
+		return nil, fmt.Errorf("获取分享列表失败: %v", err)
+	}
+
+	var data XLShareListResp
+	if err := json.Unmarshal(respData, &data); err != nil {
+		return nil, fmt.Errorf("解析分享列表失败: %v", err)
+	}
+	return &data, nil
+}
+
+// FileBatchShare 创建分享（使用 BasePanService）
+func (x *XunleiPanService) FileBatchShare(ids []string, needPassword bool, expirationDays int) (*XLBatchShareResp, error) {
+	apiURL := x.apiHost("") + "/drive/v1/share/batch"
+	body := map[string]interface{}{
+		"file_ids":        ids,
+		"need_password":   needPassword,
+		"expiration_days": expirationDays,
+	}
+
+	respData, err := x.HTTPPost(apiURL, body, nil)
+	if err != nil {
+		return nil, fmt.Errorf("创建分享失败: %v", err)
+	}
+
+	var data XLBatchShareResp
+	if err := json.Unmarshal(respData, &data); err != nil {
+		return nil, fmt.Errorf("解析分享响应失败: %v", err)
+	}
+	return &data, nil
+}
+
+// ShareBatchDelete 取消分享（使用 BasePanService）
+func (x *XunleiPanService) ShareBatchDelete(ids []string) (*XLCommonResp, error) {
+	apiURL := x.apiHost("") + "/drive/v1/share/batch/delete"
+	body := map[string]interface{}{
+		"share_ids": ids,
+	}
+
+	respData, err := x.HTTPPost(apiURL, body, nil)
+	if err != nil {
+		return nil, fmt.Errorf("删除分享失败: %v", err)
+	}
+
+	var data XLCommonResp
+	if err := json.Unmarshal(respData, &data); err != nil {
+		return nil, fmt.Errorf("解析删除响应失败: %v", err)
+	}
+	return &data, nil
+}
+
+// GetShareFolder 获取分享内容（使用 BasePanService）
+func (x *XunleiPanService) GetShareFolder(shareID, passCodeToken, parentID string) (*XLShareFolderResp, error) {
+	apiURL := x.apiHost("") + "/drive/v1/share/detail"
+	body := map[string]interface{}{
+		"share_id":        shareID,
+		"pass_code_token": passCodeToken,
+		"parent_id":       parentID,
+		"limit":           100,
+		"thumbnail_size":  "SIZE_LARGE",
+		"order":           "6",
+	}
+
+	respData, err := x.HTTPPost(apiURL, body, nil)
+	if err != nil {
+		return nil, fmt.Errorf("获取分享文件夹失败: %v", err)
+	}
+
+	var data XLShareFolderResp
+	if err := json.Unmarshal(respData, &data); err != nil {
+		return nil, fmt.Errorf("解析分享文件夹失败: %v", err)
+	}
+	return &data, nil
+}
+
+// Restore 转存（使用 BasePanService）
+func (x *XunleiPanService) Restore(shareID, passCodeToken string, fileIDs []string) (*XLRestoreResp, error) {
+	apiURL := x.apiHost("") + "/drive/v1/share/restore"
+	body := map[string]interface{}{
+		"share_id":          shareID,
+		"pass_code_token":   passCodeToken,
+		"file_ids":          fileIDs,
+		"folder_type":       "NORMAL",
+		"specify_parent_id": true,
+		"parent_id":         "",
+	}
+
+	respData, err := x.HTTPPost(apiURL, body, nil)
+	if err != nil {
+		return nil, fmt.Errorf("转存失败: %v", err)
+	}
+
+	var data XLRestoreResp
+	if err := json.Unmarshal(respData, &data); err != nil {
+		return nil, fmt.Errorf("解析转存响应失败: %v", err)
+	}
+	return &data, nil
+}
+
+// 结构体完全对齐 xunleix
+type XLShareListResp struct {
+	Data struct {
+		List []struct {
+			ShareID string `json:"share_id"`
+			Title   string `json:"title"`
+		} `json:"list"`
+	} `json:"data"`
+	Code int    `json:"code"`
+	Msg  string `json:"msg"`
+}
+
+type XLBatchShareResp struct {
+	Data struct {
+		ShareURL string `json:"share_url"`
+	} `json:"data"`
+	Code int    `json:"code"`
+	Msg  string `json:"msg"`
+}
+
+type XLCommonResp struct {
+	Code int    `json:"code"`
+	Msg  string `json:"msg"`
+}
+
+type XLShareFolderResp struct {
+	Data struct {
+		Files []struct {
+			FileID string `json:"file_id"`
+			Name   string `json:"name"`
+		} `json:"files"`
+	} `json:"data"`
+	Code int    `json:"code"`
+	Msg  string `json:"msg"`
+}
+
+type XLRestoreResp struct {
+	Data struct {
+		TaskID string `json:"task_id"`
+	} `json:"data"`
+	Code int    `json:"code"`
+	Msg  string `json:"msg"`
+}
+
+// 新增辅助结构体
+type XLShareInfo struct {
+	ShareID string       `json:"share_id"`
+	Title   string       `json:"title"`
+	Files   []XLFileInfo `json:"files"`
+}
+
+type XLFileInfo struct {
+	FileID string `json:"file_id"`
+	Name   string `json:"name"`
+}
+
+type XLTaskResult struct {
+	Status int    `json:"status"`
+	TaskID string `json:"task_id"`
+	Data   struct {
+		ShareID string `json:"share_id"`
+	} `json:"data"`
+}
--- a/common/xunlei_pan.go
+++ b/common/xunlei_pan.go
@@ -3,6 +3,7 @@ package pan
 import (
 	"encoding/json"
 	"fmt"
+	"io/ioutil"
 	"log"
 	"net/http"
 	"strconv"
@@ -32,8 +33,9 @@ type XunleiTokenData struct {
 }

 type XunleiExtraData struct {
-	Captcha *CaptchaData
-	Token   *XunleiTokenData
+	Captcha     *CaptchaData              `json:"captcha,omitempty"`
+	Token       *XunleiTokenData          `json:"token,omitempty"`
+	Credentials *XunleiAccountCredentials `json:"credentials,omitempty"` // 账号密码信息
 }

 type XunleiPanService struct {
@@ -100,9 +102,19 @@ func (x *XunleiPanService) SetCKSRepository(cksRepo repo.CksRepository, entity e
 	x.cksRepo = cksRepo
 	x.entity = entity
 	var extra XunleiExtraData
-	if err := json.Unmarshal([]byte(x.entity.Extra), &extra); err != nil {
-		log.Printf("解析 extra 数据失败: %v，使用空数据", err)
+
+	// 解析extra字段
+	if x.entity.Extra != "" {
+		if err := json.Unmarshal([]byte(x.entity.Extra), &extra); err != nil {
+			log.Printf("解析 extra 数据失败: %v", err)
+		}
 	}
+
+	// 从ck字段解析账号密码
+	if credentials, err := ParseCredentialsFromCk(x.entity.Ck); err == nil {
+		extra.Credentials = credentials
+	}
+
 	x.extra = extra
 }

@@ -151,20 +163,66 @@ func (x *XunleiPanService) GetAccessTokenByRefreshToken(refreshToken string) (Xu
 	return result, nil
 }

-// getAccessToken 获取 Access Token（内部包含缓存判断、刷新、保存）- 匹配 PHP 版本
+// reloginWithCredentials 使用账号密码重新登录
+func (x *XunleiPanService) reloginWithCredentials() (XunleiTokenData, error) {
+	if x.extra.Credentials == nil {
+		return XunleiTokenData{}, fmt.Errorf("无账号密码信息")
+	}
+
+	tokenData, err := x.LoginWithCredentials(x.extra.Credentials.Username, x.extra.Credentials.Password)
+	if err != nil {
+		return XunleiTokenData{}, fmt.Errorf("账号密码登录失败: %v", err)
+	}
+
+	log.Printf("账号 %s 重新登录成功", x.extra.Credentials.Username)
+	return tokenData, nil
+}
+
+// getAccessToken 获取 Access Token（内部包含缓存判断、刷新、重新登录、保存）
 func (x *XunleiPanService) getAccessToken() (string, error) {
 	// 检查 Access Token 是否有效
 	currentTime := time.Now().Unix()
 	if x.extra.Token != nil && x.extra.Token.AccessToken != "" && x.extra.Token.ExpiresAt > currentTime {
 		return x.extra.Token.AccessToken, nil
 	}
-	newData, err := x.GetAccessTokenByRefreshToken(x.extra.Token.RefreshToken)
-	if err != nil {
-		return "", fmt.Errorf("获取 access_token 失败: %v", err)
+
+	// 尝试使用refresh_token刷新
+	var newData XunleiTokenData
+	var err error
+
+	if x.extra.Token != nil && x.extra.Token.RefreshToken != "" {
+		newData, err = x.GetAccessTokenByRefreshToken(x.extra.Token.RefreshToken)
+		if err != nil {
+			log.Printf("refresh_token刷新失败: %v，尝试使用账号密码重新登录", err)
+
+			// 如果refresh_token失效且有账号密码信息，尝试重新登录
+			if x.extra.Credentials != nil && x.extra.Credentials.Username != "" && x.extra.Credentials.Password != "" {
+				newData, err = x.reloginWithCredentials()
+				if err != nil {
+					return "", fmt.Errorf("重新登录失败: %v", err)
+				}
+			} else {
+				return "", fmt.Errorf("refresh_token失效且无账号密码信息，无法重新登录: %v", err)
+			}
+		}
+	} else {
+		return "", fmt.Errorf("无有效的refresh_token")
 	}

+	// 更新token信息
+	if x.extra.Token == nil {
+		x.extra.Token = &XunleiTokenData{}
+	}
 	x.extra.Token.AccessToken = newData.AccessToken
+	x.extra.Token.RefreshToken = newData.RefreshToken
 	x.extra.Token.ExpiresAt = newData.ExpiresAt
+	x.extra.Token.ExpiresIn = newData.ExpiresIn
+	x.extra.Token.Sub = newData.Sub
+	x.extra.Token.TokenType = newData.TokenType
+	x.extra.Token.UserId = newData.UserId
+
+	// 更新ck字段中的refresh_token（保持向后兼容）
+	x.entity.Ck = newData.RefreshToken

 	// 保存到数据库
 	extraBytes, err := json.Marshal(x.extra)
@@ -175,6 +233,7 @@ func (x *XunleiPanService) getAccessToken() (string, error) {
 	if err := x.cksRepo.UpdateWithAllFields(&x.entity); err != nil {
 		return "", fmt.Errorf("保存 access_token 到数据库失败: %v", err)
 	}
+
 	return newData.AccessToken, nil
 }

@@ -248,6 +307,12 @@ func (x *XunleiPanService) requestXunleiApi(url string, method string, data map[
 	var respData []byte
 	var err error

+	// 检查是否是验证码初始化请求
+	if strings.Contains(url, "shield/captcha/init") {
+		// 对于验证码初始化，直接发送HTTP请求，不使用BasePanService，使用sendCaptchaRequestForGeneralAPI
+		return x.sendCaptchaRequestForGeneralAPI(url, data)
+	}
+
 	// 先更新当前请求的 headers
 	originalHeaders := make(map[string]string)
 	for k, v := range x.headers {
@@ -832,6 +897,51 @@ func (x *XunleiPanService) Restore(shareID, passCodeToken string, fileIDs []stri
 	return &data, nil
 }

+// sendCaptchaRequestForGeneralAPI 发送验证码请求 - 用于非登录场景的验证码请求
+func (x *XunleiPanService) sendCaptchaRequestForGeneralAPI(url string, data map[string]interface{}) (map[string]interface{}, error) {
+	jsonData, err := json.Marshal(data)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Printf("发送验证码请求URL: %s", url)
+	log.Printf("发送验证码请求数据: %s", string(jsonData))
+
+	req, err := http.NewRequest("POST", url, strings.NewReader(string(jsonData)))
+	if err != nil {
+		return nil, err
+	}
+
+	// 设置请求头
+	req.Header.Set("Content-Type", "application/json")
+	req.Header.Set("User-Agent", "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/91.0.4472.124 Safari/537.36")
+	req.Header.Set("X-Client-Id", x.clientId)
+	req.Header.Set("X-Device-Id", x.deviceId)
+
+	client := &http.Client{Timeout: 10 * time.Second}
+	resp, err := client.Do(req)
+	if err != nil {
+		return nil, err
+	}
+	defer resp.Body.Close()
+
+	body, err := ioutil.ReadAll(resp.Body)
+	if err != nil {
+		return nil, err
+	}
+
+	log.Printf("验证码响应状态码: %d", resp.StatusCode)
+	log.Printf("验证码响应内容: %s", string(body))
+
+	var result map[string]interface{}
+	if err := json.Unmarshal(body, &result); err != nil {
+		return nil, fmt.Errorf("JSON 解析失败: %v, raw: %s", err, string(body))
+	}
+
+	log.Printf("解析后的响应: %+v", result)
+	return result, nil
+}
+
 // 结构体完全对齐 xunleix
 type XLShareListResp struct {
 	Data struct {
@@ -894,4 +1004,4 @@ type XLTaskResult struct {
 	Data   struct {
 		ShareID string `json:"share_id"`
 	} `json:"data"`
-}
+}
--- a/db/connection.go
+++ b/db/connection.go
@@ -209,7 +209,15 @@ func createIndexes(db *gorm.DB) {
 	db.Exec("CREATE INDEX IF NOT EXISTS idx_resource_tags_resource_id ON resource_tags(resource_id)")
 	db.Exec("CREATE INDEX IF NOT EXISTS idx_resource_tags_tag_id ON resource_tags(tag_id)")

-	utils.Info("数据库索引创建完成（已移除全文搜索索引，准备使用Meilisearch）")
+	// API访问日志表索引 - 高性能查询优化
+	db.Exec("CREATE INDEX IF NOT EXISTS idx_api_access_logs_created_at ON api_access_logs(created_at DESC)")
+	db.Exec("CREATE INDEX IF NOT EXISTS idx_api_access_logs_endpoint_status ON api_access_logs(endpoint, response_status)")
+	db.Exec("CREATE INDEX IF NOT EXISTS idx_api_access_logs_ip_created ON api_access_logs(ip, created_at DESC)")
+	db.Exec("CREATE INDEX IF NOT EXISTS idx_api_access_logs_method_endpoint ON api_access_logs(method, endpoint)")
+	db.Exec("CREATE INDEX IF NOT EXISTS idx_api_access_logs_response_time ON api_access_logs(processing_time)")
+	db.Exec("CREATE INDEX IF NOT EXISTS idx_api_access_logs_error_logs ON api_access_logs(response_status, created_at DESC) WHERE response_status >= 400")
+
+	utils.Info("数据库索引创建完成（已移除全文搜索索引，准备使用Meilisearch，新增API访问日志性能索引）")
 }

 // insertDefaultDataIfEmpty 只在数据库为空时插入默认数据
--- a/db/dto/response.go
+++ b/db/dto/response.go
@@ -72,19 +72,20 @@ type PanResponse struct {

 // CksResponse Cookie响应
 type CksResponse struct {
-	ID          uint         `json:"id"`
-	PanID       uint         `json:"pan_id"`
-	Idx         int          `json:"idx"`
-	Ck          string       `json:"ck"`
-	IsValid     bool         `json:"is_valid"`
-	Space       int64        `json:"space"`
-	LeftSpace   int64        `json:"left_space"`
-	UsedSpace   int64        `json:"used_space"`
-	Username    string       `json:"username"`
-	VipStatus   bool         `json:"vip_status"`
-	ServiceType string       `json:"service_type"`
-	Remark      string       `json:"remark"`
-	Pan         *PanResponse `json:"pan,omitempty"`
+	ID                uint         `json:"id"`
+	PanID             uint         `json:"pan_id"`
+	Idx               int          `json:"idx"`
+	Ck                string       `json:"ck"`
+	IsValid           bool         `json:"is_valid"`
+	Space             int64        `json:"space"`
+	LeftSpace         int64        `json:"left_space"`
+	UsedSpace         int64        `json:"used_space"`
+	Username          string       `json:"username"`
+	VipStatus         bool         `json:"vip_status"`
+	ServiceType       string       `json:"service_type"`
+	Remark            string       `json:"remark"`
+	TransferredCount  int64        `json:"transferred_count"` // 已转存资源数
+	Pan               *PanResponse `json:"pan,omitempty"`
 }

 // ReadyResourceResponse 待处理资源响应
--- a/db/repo/resource_repository.go
+++ b/db/repo/resource_repository.go
@@ -44,6 +44,8 @@ type ResourceRepository interface {
 	MarkAllAsUnsyncedToMeilisearch() error
 	FindAllWithPagination(page, limit int) ([]entity.Resource, int64, error)
 	GetRandomResourceWithFilters(categoryFilter, tagFilter string, isPushSavedInfo bool) (*entity.Resource, error)
+	DeleteRelatedResources(ckID uint) (int64, error)
+	CountResourcesByCkID(ckID uint) (int64, error)
 }

 // ResourceRepositoryImpl Resource的Repository实现
@@ -650,3 +652,29 @@ func (r *ResourceRepositoryImpl) GetRandomResourceWithFilters(categoryFilter, ta

 	return &resource, nil
 }
+
+// DeleteRelatedResources 删除关联资源，清空 fid、ck_id 和 save_url 三个字段
+func (r *ResourceRepositoryImpl) DeleteRelatedResources(ckID uint) (int64, error) {
+	result := r.db.Model(&entity.Resource{}).
+		Where("ck_id = ?", ckID).
+		Updates(map[string]interface{}{
+			"fid":      nil, // 清空 fid 字段
+			"ck_id":    0,   // 清空 ck_id 字段
+			"save_url": "",  // 清空 save_url 字段
+		})
+
+	if result.Error != nil {
+		return 0, result.Error
+	}
+
+	return result.RowsAffected, nil
+}
+
+// CountResourcesByCkID 统计指定账号ID的资源数量
+func (r *ResourceRepositoryImpl) CountResourcesByCkID(ckID uint) (int64, error) {
+	var count int64
+	err := r.db.Model(&entity.Resource{}).
+		Where("ck_id = ?", ckID).
+		Count(&count).Error
+	return count, err
+}
--- a/docker-compose.yml
+++ b/docker-compose.yml
@@ -20,7 +20,7 @@ services:
      - app-network

  backend:
-    image: ctwj/urldb-backend:1.3.3
+    image: ctwj/urldb-backend:1.3.4
    environment:
      DB_HOST: postgres
      DB_PORT: 5432
@@ -38,7 +38,7 @@ services:
      - app-network

  frontend:
-    image: ctwj/urldb-frontend:1.3.3
+    image: ctwj/urldb-frontend:1.3.4
    environment:
      NODE_ENV: production
      NUXT_PUBLIC_API_SERVER: http://backend:8080/api
--- a/handlers/cks_handler.go
+++ b/handlers/cks_handler.go
@@ -2,6 +2,7 @@ package handlers

 import (
 	"encoding/json"
+	"log"
 	"net/http"
 	"strconv"
 	"strings"
@@ -22,7 +23,49 @@ func GetCks(c *gin.Context) {
 		return
 	}

-	responses := converter.ToCksResponseList(cks)
+	// 使用新的逻辑创建 CksResponse
+	var responses []dto.CksResponse
+	for _, ck := range cks {
+		// 获取平台信息
+		var pan *dto.PanResponse
+		if ck.PanID != 0 {
+			panEntity, err := repoManager.PanRepository.FindByID(ck.PanID)
+			if err == nil && panEntity != nil {
+				pan = &dto.PanResponse{
+					ID:     panEntity.ID,
+					Name:   panEntity.Name,
+					Key:    panEntity.Key,
+					Icon:   panEntity.Icon,
+					Remark: panEntity.Remark,
+				}
+			}
+		}
+
+		// 统计转存资源数
+		count, err := repoManager.ResourceRepository.CountResourcesByCkID(ck.ID)
+		if err != nil {
+			count = 0 // 统计失败时设为0
+		}
+
+		response := dto.CksResponse{
+			ID:               ck.ID,
+			PanID:            ck.PanID,
+			Idx:              ck.Idx,
+			Ck:               ck.Ck,
+			IsValid:          ck.IsValid,
+			Space:            ck.Space,
+			LeftSpace:        ck.LeftSpace,
+			UsedSpace:        ck.UsedSpace,
+			Username:         ck.Username,
+			VipStatus:        ck.VipStatus,
+			ServiceType:      ck.ServiceType,
+			Remark:           ck.Remark,
+			TransferredCount: count,
+			Pan:              pan,
+		}
+		responses = append(responses, response)
+	}
+
 	SuccessResponse(c, responses)
 }

@@ -68,32 +111,81 @@ func CreateCks(c *gin.Context) {
 	}

 	var cks *entity.Cks
-	// 迅雷网盘，添加的时候 只获取token就好， 然后刷新的时候， 再补充用户信息等
+	// 迅雷网盘，使用账号密码登录
 	if serviceType == panutils.Xunlei {
-		xunleiService := service.(*panutils.XunleiPanService)
-		tokenData, err := xunleiService.GetAccessTokenByRefreshToken(req.Ck)
+		// 解析账号密码信息
+		credentials, err := panutils.ParseCredentialsFromCk(req.Ck)
 		if err != nil {
-			ErrorResponse(c, "无法获取有效token: "+err.Error(), http.StatusBadRequest)
+			ErrorResponse(c, "账号密码格式错误: "+err.Error(), http.StatusBadRequest)
 			return
 		}
+
+		// 验证账号密码
+		if credentials.Username == "" || credentials.Password == "" {
+			ErrorResponse(c, "请提供完整的账号和密码", http.StatusBadRequest)
+			return
+		}
+
+		var tokenData *panutils.XunleiTokenData
+		var username string
+
+		// 使用账号密码登录
+		xunleiService := service.(*panutils.XunleiPanService)
+		token, err := xunleiService.LoginWithCredentials(credentials.Username, credentials.Password)
+		if err != nil {
+			ErrorResponse(c, "账号密码登录失败: "+err.Error(), http.StatusBadRequest)
+			return
+		}
+		tokenData = &token
+		username = credentials.Username
+
+		// 构建extra数据
 		extra := panutils.XunleiExtraData{
-			Token:   &tokenData,
+			Token:   tokenData,
 			Captcha: &panutils.CaptchaData{},
 		}
+
+		// 如果有账号密码信息，保存到extra中
+		if credentials.Username != "" && credentials.Password != "" {
+			extra.Credentials = credentials
+		}
+
 		extraStr, _ := json.Marshal(extra)

+		// 声明userInfo变量
+		var userInfo *panutils.UserInfo
+
+		// 设置CKSRepository以便获取用户信息
+		xunleiService.SetCKSRepository(repoManager.CksRepository, entity.Cks{})
+
+		// 获取用户信息
+		userInfo, err = xunleiService.GetUserInfo(nil)
+		if err != nil {
+			log.Printf("获取迅雷用户信息失败，使用默认值: %v", err)
+			// 如果获取失败，使用默认值
+			userInfo = &panutils.UserInfo{
+				Username:    username,
+				VIPStatus:   false,
+				ServiceType: "xunlei",
+				TotalSpace:  0,
+				UsedSpace:   0,
+			}
+		}
+
+		leftSpaceBytes := userInfo.TotalSpace - userInfo.UsedSpace
+
 		// 创建Cks实体
 		cks = &entity.Cks{
 			PanID:       req.PanID,
 			Idx:         req.Idx,
-			Ck:          tokenData.RefreshToken,
-			IsValid:     true, // 根据VIP状态设置有效性
-			Space:       0,
-			LeftSpace:   0,
-			UsedSpace:   0,
-			Username:    "-",
-			VipStatus:   false,
-			ServiceType: "xunlei",
+			Ck:          req.Ck, // 保持原始输入
+			IsValid:     userInfo.VIPStatus, // 根据VIP状态设置有效性
+			Space:       userInfo.TotalSpace,
+			LeftSpace:   leftSpaceBytes,
+			UsedSpace:   userInfo.UsedSpace,
+			Username:    userInfo.Username,
+			VipStatus:   userInfo.VIPStatus,
+			ServiceType: userInfo.ServiceType,
 			Extra:       string(extraStr),
 			Remark:      req.Remark,
 		}
@@ -346,14 +438,16 @@ func RefreshCapacity(c *gin.Context) {

 	var userInfo *panutils.UserInfo
 	service.SetCKSRepository(repoManager.CksRepository, *cks) // 迅雷需要初始化 token 后才能获取，
-	userInfo, err = service.GetUserInfo(&cks.Ck)
-	// switch s := service.(type) {
-	// case *panutils.XunleiPanService:

-	// 	userInfo, err = s.GetUserInfo(nil)
-	// default:
-	// 	userInfo, err = service.GetUserInfo(&cks.Ck)
-	// }
+	// 根据服务类型调用不同的GetUserInfo方法
+	switch s := service.(type) {
+	case *panutils.XunleiPanService:
+		// 迅雷网盘使用存储在extra中的token，不需要传递ck参数
+		userInfo, err = s.GetUserInfo(nil)
+	default:
+		// 其他网盘使用ck参数
+		userInfo, err = service.GetUserInfo(&cks.Ck)
+	}
 	if err != nil {
 		ErrorResponse(c, "无法获取用户信息，刷新失败: "+err.Error(), http.StatusBadRequest)
 		return
@@ -380,3 +474,25 @@ func RefreshCapacity(c *gin.Context) {
 		"cks":     converter.ToCksResponse(cks),
 	})
 }
+
+// DeleteRelatedResources 删除关联资源
+func DeleteRelatedResources(c *gin.Context) {
+	idStr := c.Param("id")
+	id, err := strconv.ParseUint(idStr, 10, 32)
+	if err != nil {
+		ErrorResponse(c, "无效的ID", http.StatusBadRequest)
+		return
+	}
+
+	// 调用资源库删除关联资源
+	affectedRows, err := repoManager.ResourceRepository.DeleteRelatedResources(uint(id))
+	if err != nil {
+		ErrorResponse(c, "删除关联资源失败: "+err.Error(), http.StatusInternalServerError)
+		return
+	}
+
+	SuccessResponse(c, gin.H{
+		"message":       "关联资源删除成功",
+		"affected_rows": affectedRows,
+	})
+}
--- a/handlers/public_api_handler.go
+++ b/handlers/public_api_handler.go
@@ -1,6 +1,7 @@
 package handlers

 import (
+	"encoding/json"
 	"strconv"
 	"strings"
 	"time"
@@ -91,30 +92,9 @@ func (h *PublicAPIHandler) logAPIAccess(c *gin.Context, startTime time.Time, pro
 		}
 	}

-	// 异步记录日志，避免影响API响应时间
-	go func() {
-		defer func() {
-			if r := recover(); r != nil {
-				utils.Error("记录API访问日志时发生panic: %v", r)
-			}
-		}()
-
-		err := repoManager.APIAccessLogRepository.RecordAccess(
-			ip,
-			userAgent,
-			endpoint,
-			method,
-			requestParams,
-			c.Writer.Status(),
-			responseData,
-			processCount,
-			errorMessage,
-			processingTime,
-		)
-		if err != nil {
-			utils.Error("记录API访问日志失败: %v", err)
-		}
-	}()
+	// 记录API访问日志 - 使用简单日志记录
+	h.recordAPIAccessToDB(ip, userAgent, endpoint, method, requestParams,
+		c.Writer.Status(), responseData, processCount, errorMessage, processingTime)
 }

 // AddBatchResources godoc
@@ -466,3 +446,49 @@ func (h *PublicAPIHandler) GetHotDramas(c *gin.Context) {
 	h.logAPIAccess(c, startTime, len(hotDramaResponses), responseData, "")
 	SuccessResponse(c, responseData)
 }
+
+// recordAPIAccessToDB 记录API访问日志到数据库
+func (h *PublicAPIHandler) recordAPIAccessToDB(ip, userAgent, endpoint, method string,
+	requestParams interface{}, responseStatus int, responseData interface{},
+	processCount int, errorMessage string, processingTime int64) {
+
+	// 只记录重要的API访问（有错误或处理时间较长的）
+	if errorMessage == "" && processingTime < 1000 && responseStatus < 400 {
+		return // 跳过正常的快速请求
+	}
+
+	// 转换参数为JSON字符串
+	var requestParamsStr, responseDataStr string
+	if requestParams != nil {
+		if jsonBytes, err := json.Marshal(requestParams); err == nil {
+			requestParamsStr = string(jsonBytes)
+		}
+	}
+	if responseData != nil {
+		if jsonBytes, err := json.Marshal(responseData); err == nil {
+			responseDataStr = string(jsonBytes)
+		}
+	}
+
+	// 创建日志记录
+	logEntry := &entity.APIAccessLog{
+		IP:             ip,
+		UserAgent:      userAgent,
+		Endpoint:       endpoint,
+		Method:         method,
+		RequestParams:  requestParamsStr,
+		ResponseStatus: responseStatus,
+		ResponseData:   responseDataStr,
+		ProcessCount:   processCount,
+		ErrorMessage:   errorMessage,
+		ProcessingTime: processingTime,
+	}
+
+	// 异步保存到数据库（避免影响API性能）
+	go func() {
+		if err := repoManager.APIAccessLogRepository.Create(logEntry); err != nil {
+			// 记录失败只输出到系统日志，不影响API
+			utils.Error("保存API访问日志失败: %v", err)
+		}
+	}()
+}
--- a/handlers/system_config_handler.go
+++ b/handlers/system_config_handler.go
@@ -145,27 +145,26 @@ func UpdateSystemConfig(c *gin.Context) {
 		utils.Info("当前配置数量: %d", len(currentConfigs))
 	}

-	// 验证参数 - 只验证提交的字段
-	utils.Info("开始验证参数")
+	// 验证参数 - 只验证提交的字段，仅在验证失败时记录日志
 	if req.SiteTitle != nil {
-		utils.Info("验证SiteTitle: '%s', 长度: %d", *req.SiteTitle, len(*req.SiteTitle))
 		if len(*req.SiteTitle) < 1 || len(*req.SiteTitle) > 100 {
+			utils.Warn("配置验证失败 - SiteTitle长度无效: %d", len(*req.SiteTitle))
 			ErrorResponse(c, "网站标题长度必须在1-100字符之间", http.StatusBadRequest)
 			return
 		}
 	}

 	if req.AutoProcessInterval != nil {
-		utils.Info("验证AutoProcessInterval: %d", *req.AutoProcessInterval)
 		if *req.AutoProcessInterval < 1 || *req.AutoProcessInterval > 1440 {
+			utils.Warn("配置验证失败 - AutoProcessInterval超出范围: %d", *req.AutoProcessInterval)
 			ErrorResponse(c, "自动处理间隔必须在1-1440分钟之间", http.StatusBadRequest)
 			return
 		}
 	}

 	if req.PageSize != nil {
-		utils.Info("验证PageSize: %d", *req.PageSize)
 		if *req.PageSize < 10 || *req.PageSize > 500 {
+			utils.Warn("配置验证失败 - PageSize超出范围: %d", *req.PageSize)
 			ErrorResponse(c, "每页显示数量必须在10-500之间", http.StatusBadRequest)
 			return
 		}
@@ -173,36 +172,34 @@ func UpdateSystemConfig(c *gin.Context) {

 	// 验证自动转存配置
 	if req.AutoTransferLimitDays != nil {
-		utils.Info("验证AutoTransferLimitDays: %d", *req.AutoTransferLimitDays)
 		if *req.AutoTransferLimitDays < 0 || *req.AutoTransferLimitDays > 365 {
+			utils.Warn("配置验证失败 - AutoTransferLimitDays超出范围: %d", *req.AutoTransferLimitDays)
 			ErrorResponse(c, "自动转存限制天数必须在0-365之间", http.StatusBadRequest)
 			return
 		}
 	}

 	if req.AutoTransferMinSpace != nil {
-		utils.Info("验证AutoTransferMinSpace: %d", *req.AutoTransferMinSpace)
-		if *req.AutoTransferMinSpace < 100 || *req.AutoTransferMinSpace > 1024 {
-			ErrorResponse(c, "最小存储空间必须在100-1024GB之间", http.StatusBadRequest)
+		if *req.AutoTransferMinSpace < 5 || *req.AutoTransferMinSpace > 1024 {
+			utils.Warn("配置验证失败 - AutoTransferMinSpace超出范围: %d", *req.AutoTransferMinSpace)
+			ErrorResponse(c, "最小存储空间必须在5-1024GB之间", http.StatusBadRequest)
 			return
 		}
 	}

 	// 验证公告相关字段
 	if req.Announcements != nil {
-		utils.Info("验证Announcements: '%s'", *req.Announcements)
-		// 可以在这里添加更详细的验证逻辑
+		// 简化验证，仅在需要时添加逻辑
 	}

 	// 转换为实体
 	configs := converter.RequestToSystemConfig(&req)
 	if configs == nil {
+		utils.Error("配置数据转换失败")
 		ErrorResponse(c, "数据转换失败", http.StatusInternalServerError)
 		return
 	}

-	utils.Info("准备更新配置，配置项数量: %d", len(configs))
-
 	// 保存配置
 	err = repoManager.SystemConfigRepository.UpsertConfigs(configs)
 	if err != nil {
@@ -211,7 +208,7 @@ func UpdateSystemConfig(c *gin.Context) {
 		return
 	}

-	utils.Info("配置保存成功")
+	utils.Info("系统配置更新成功 - 更新项数: %d", len(configs))

 	// 安全刷新系统配置缓存
 	if err := repoManager.SystemConfigRepository.SafeRefreshConfigCache(); err != nil {
--- a/handlers/telegram_handler.go
+++ b/handlers/telegram_handler.go
@@ -80,16 +80,40 @@ func (h *TelegramHandler) UpdateBotConfig(c *gin.Context) {
 		return
 	}

-	// 配置更新完成后，尝试启动机器人（如果未运行且配置有效）
-	if startErr := h.telegramBotService.Start(); startErr != nil {
-		utils.Warn("[TELEGRAM:HANDLER] 配置更新后尝试启动机器人失败: %v", startErr)
-		// 启动失败不影响配置保存，只记录警告
+	// 根据配置状态决定启动或停止机器人
+	botEnabled := false
+	for _, config := range configs {
+		if config.Key == "telegram_bot_enabled" {
+			botEnabled = config.Value == "true"
+			break
+		}
+	}
+
+	if botEnabled {
+		// 机器人已启用，尝试启动机器人
+		if startErr := h.telegramBotService.Start(); startErr != nil {
+			utils.Warn("[TELEGRAM:HANDLER] 配置更新后尝试启动机器人失败: %v", startErr)
+			// 启动失败不影响配置保存，只记录警告
+		}
+	} else {
+		// 机器人已禁用，停止机器人服务
+		if stopErr := h.telegramBotService.Stop(); stopErr != nil {
+			utils.Warn("[TELEGRAM:HANDLER] 配置更新后停止机器人失败: %v", stopErr)
+			// 停止失败不影响配置保存，只记录警告
+		}
 	}

 	// 返回成功
+	var message string
+	if botEnabled {
+		message = "配置更新成功，机器人已尝试启动"
+	} else {
+		message = "配置更新成功，机器人已停止"
+	}
+
 	SuccessResponse(c, map[string]interface{}{
 		"success": true,
-		"message": "配置更新成功，机器人已尝试启动",
+		"message": message,
 	})
 }

--- a/main.go
+++ b/main.go
@@ -4,7 +4,9 @@ import (
 	"fmt"
 	"log"
 	"os"
+	"os/signal"
 	"strings"
+	"syscall"
 	"time"

 	"github.com/ctwj/urldb/config"
@@ -38,7 +40,7 @@ func main() {
 	}

 	// 初始化日志系统
-	if err := utils.InitLogger(nil); err != nil {
+	if err := utils.InitLogger(); err != nil {
 		log.Fatal("初始化日志系统失败:", err)
 	}

@@ -84,6 +86,8 @@ func main() {
 		utils.Fatal("数据库连接失败: %v", err)
 	}

+	// 日志系统已简化，无需额外初始化
+
 	// 创建Repository管理器
 	repoManager := repo.NewRepositoryManager(db.DB)

@@ -265,6 +269,7 @@ func main() {
 		api.DELETE("/cks/:id", middleware.AuthMiddleware(), middleware.AdminMiddleware(), handlers.DeleteCks)
 		api.GET("/cks/:id", middleware.AuthMiddleware(), middleware.AdminMiddleware(), handlers.GetCksByID)
 		api.POST("/cks/:id/refresh-capacity", middleware.AuthMiddleware(), middleware.AdminMiddleware(), handlers.RefreshCapacity)
+		api.POST("/cks/:id/delete-related-resources", middleware.AuthMiddleware(), middleware.AdminMiddleware(), handlers.DeleteRelatedResources)

 		// 标签管理
 		api.GET("/tags", handlers.GetTags)
@@ -462,6 +467,21 @@ func main() {
 		port = "8080"
 	}

-	utils.Info("服务器启动在端口 %s", port)
-	r.Run(":" + port)
+	// 设置优雅关闭
+	quit := make(chan os.Signal, 1)
+	signal.Notify(quit, syscall.SIGINT, syscall.SIGTERM)
+
+	// 在goroutine中启动服务器
+	go func() {
+		utils.Info("服务器启动在端口 %s", port)
+		if err := r.Run(":" + port); err != nil && err.Error() != "http: Server closed" {
+			utils.Fatal("服务器启动失败: %v", err)
+		}
+	}()
+
+	// 等待信号
+	<-quit
+	utils.Info("收到关闭信号，开始优雅关闭...")
+
+	utils.Info("服务器已优雅关闭")
 }
--- a/middleware/auth.go
+++ b/middleware/auth.go
@@ -34,7 +34,7 @@ func AuthMiddleware() gin.HandlerFunc {
 			c.Request.Method, c.Request.URL.Path, clientIP, userAgent)

 		if authHeader == "" {
-			utils.Warn("AuthMiddleware - 未提供认证令牌 - IP: %s, Path: %s", clientIP, c.Request.URL.Path)
+			// utils.Warn("AuthMiddleware - 未提供认证令牌 - IP: %s, Path: %s", clientIP, c.Request.URL.Path)
 			c.JSON(http.StatusUnauthorized, gin.H{"error": "未提供认证令牌"})
 			c.Abort()
 			return
@@ -59,8 +59,8 @@ func AuthMiddleware() gin.HandlerFunc {
 			return
 		}

-		utils.Info("AuthMiddleware - 认证成功 - 用户: %s(ID:%d), 角色: %s, IP: %s",
-			claims.Username, claims.UserID, claims.Role, clientIP)
+		// utils.Info("AuthMiddleware - 认证成功 - 用户: %s(ID:%d), 角色: %s, IP: %s",
+		// 	claims.Username, claims.UserID, claims.Role, clientIP)

 		// 将用户信息存储到上下文中
 		c.Set("user_id", claims.UserID)
--- a/middleware/logging.go
+++ b/middleware/logging.go
@@ -4,6 +4,7 @@ import (
 	"bytes"
 	"io"
 	"net/http"
+	"strings"
 	"time"

 	"github.com/ctwj/urldb/utils"
@@ -55,41 +56,64 @@ func LoggingMiddleware(next http.Handler) http.Handler {
 	})
 }

-// logRequest 记录请求日志
+// logRequest 记录请求日志 - 优化后仅记录异常和关键请求
 func logRequest(r *http.Request, rw *responseWriter, duration time.Duration, requestBody []byte) {
 	// 获取客户端IP
 	clientIP := getClientIP(r)

-	// 获取用户代理
-	userAgent := r.UserAgent()
-	if userAgent == "" {
-		userAgent = "Unknown"
+	// 判断是否需要记录日志的条件
+	shouldLog := rw.statusCode >= 400 || // 错误状态码
+		duration > 5*time.Second || // 耗时过长
+		shouldLogPath(r.URL.Path) || // 关键路径
+		isAdminPath(r.URL.Path) // 管理员路径
+
+	if !shouldLog {
+		return // 正常请求不记录日志，减少日志噪音
 	}

-	// 记录请求信息
-	utils.Info("HTTP请求 - %s %s - IP: %s - User-Agent: %s - 状态码: %d - 耗时: %v",
-		r.Method, r.URL.Path, clientIP, userAgent, rw.statusCode, duration)
-
-	// 如果是错误状态码，记录详细信息
+	// 简化的日志格式，移除User-Agent以减少噪音
 	if rw.statusCode >= 400 {
-		utils.Error("HTTP错误 - %s %s - 状态码: %d - 响应体: %s",
-			r.Method, r.URL.Path, rw.statusCode, rw.body.String())
+		// 错误请求记录详细信息
+		utils.Error("HTTP异常 - %s %s - IP: %s - 状态码: %d - 耗时: %v",
+			r.Method, r.URL.Path, clientIP, rw.statusCode, duration)
+
+		// 仅在错误状态下记录简要的请求信息
+		if len(requestBody) > 0 && len(requestBody) <= 500 {
+			utils.Error("请求详情: %s", string(requestBody))
+		}
+	} else if duration > 5*time.Second {
+		// 慢请求警告
+		utils.Warn("HTTP慢请求 - %s %s - IP: %s - 耗时: %v",
+			r.Method, r.URL.Path, clientIP, duration)
+	} else {
+		// 关键路径的正常请求
+		utils.Info("HTTP关键请求 - %s %s - IP: %s - 状态码: %d - 耗时: %v",
+			r.Method, r.URL.Path, clientIP, rw.statusCode, duration)
+	}
+}
+
+// shouldLogPath 判断路径是否需要记录日志
+func shouldLogPath(path string) bool {
+	// 定义需要记录日志的关键路径
+	keyPaths := []string{
+		"/api/public/resources",
+		"/api/admin/config",
+		"/api/admin/users",
+		"/telegram/webhook",
 	}

-	// 记录请求参数（仅对POST/PUT请求）
-	if (r.Method == "POST" || r.Method == "PUT") && len(requestBody) > 0 {
-		// 限制日志长度，避免日志文件过大
-		if len(requestBody) > 1000 {
-			utils.Debug("请求体(截断): %s...", string(requestBody[:1000]))
-		} else {
-			utils.Debug("请求体: %s", string(requestBody))
+	for _, keyPath := range keyPaths {
+		if strings.HasPrefix(path, keyPath) {
+			return true
 		}
 	}
+	return false
+}

-	// 记录查询参数
-	if len(r.URL.RawQuery) > 0 {
-		utils.Debug("查询参数: %s", r.URL.RawQuery)
-	}
+// isAdminPath 判断是否为管理员路径
+func isAdminPath(path string) bool {
+	return strings.HasPrefix(path, "/api/admin/") ||
+		   strings.HasPrefix(path, "/admin/")
 }

 // getClientIP 获取客户端真实IP地址
--- a/services/telegram_bot_service.go
+++ b/services/telegram_bot_service.go
@@ -52,6 +52,7 @@ type TelegramBotServiceImpl struct {
 	config           *TelegramBotConfig
 	pushHistory      map[int64][]uint // 每个频道的推送历史记录，最多100条
 	mu               sync.RWMutex     // 用于保护pushHistory的读写锁
+	stopChan         chan struct{}    // 用于停止消息循环的channel
 }

 type TelegramBotConfig struct {
@@ -84,6 +85,7 @@ func NewTelegramBotService(
 		cronScheduler:    cron.New(),
 		config:           &TelegramBotConfig{},
 		pushHistory:      make(map[int64][]uint),
+		stopChan:         make(chan struct{}),
 	}
 }

@@ -111,57 +113,55 @@ func (s *TelegramBotServiceImpl) loadConfig() error {
 	s.config.ProxyUsername = ""
 	s.config.ProxyPassword = ""

+	// 统计配置项数量，用于汇总日志
+	configCount := 0
+
 	for _, config := range configs {
 		switch config.Key {
 		case entity.ConfigKeyTelegramBotEnabled:
 			s.config.Enabled = config.Value == "true"
-			utils.Info("[TELEGRAM:CONFIG] 加载配置 %s = %s (Enabled: %v)", config.Key, config.Value, s.config.Enabled)
 		case entity.ConfigKeyTelegramBotApiKey:
 			s.config.ApiKey = config.Value
-			utils.Info("[TELEGRAM:CONFIG] 加载配置 %s = [HIDDEN]", config.Key)
 		case entity.ConfigKeyTelegramAutoReplyEnabled:
 			s.config.AutoReplyEnabled = config.Value == "true"
-			utils.Info("[TELEGRAM:CONFIG] 加载配置 %s = %s (AutoReplyEnabled: %v)", config.Key, config.Value, s.config.AutoReplyEnabled)
 		case entity.ConfigKeyTelegramAutoReplyTemplate:
 			if config.Value != "" {
 				s.config.AutoReplyTemplate = config.Value
 			}
-			utils.Info("[TELEGRAM:CONFIG] 加载配置 %s = %s", config.Key, config.Value)
 		case entity.ConfigKeyTelegramAutoDeleteEnabled:
 			s.config.AutoDeleteEnabled = config.Value == "true"
-			utils.Info("[TELEGRAM:CONFIG] 加载配置 %s = %s (AutoDeleteEnabled: %v)", config.Key, config.Value, s.config.AutoDeleteEnabled)
 		case entity.ConfigKeyTelegramAutoDeleteInterval:
 			if config.Value != "" {
 				fmt.Sscanf(config.Value, "%d", &s.config.AutoDeleteInterval)
 			}
-			utils.Info("[TELEGRAM:CONFIG] 加载配置 %s = %s (AutoDeleteInterval: %d)", config.Key, config.Value, s.config.AutoDeleteInterval)
 		case entity.ConfigKeyTelegramProxyEnabled:
 			s.config.ProxyEnabled = config.Value == "true"
-			utils.Info("[TELEGRAM:CONFIG] 加载配置 %s = %s (ProxyEnabled: %v)", config.Key, config.Value, s.config.ProxyEnabled)
 		case entity.ConfigKeyTelegramProxyType:
 			s.config.ProxyType = config.Value
-			utils.Info("[TELEGRAM:CONFIG] 加载配置 %s = %s (ProxyType: %s)", config.Key, config.Value, s.config.ProxyType)
 		case entity.ConfigKeyTelegramProxyHost:
 			s.config.ProxyHost = config.Value
-			utils.Info("[TELEGRAM:CONFIG] 加载配置 %s = %s", config.Key, "[HIDDEN]")
 		case entity.ConfigKeyTelegramProxyPort:
 			if config.Value != "" {
 				fmt.Sscanf(config.Value, "%d", &s.config.ProxyPort)
 			}
-			utils.Info("[TELEGRAM:CONFIG] 加载配置 %s = %s (ProxyPort: %d)", config.Key, config.Value, s.config.ProxyPort)
 		case entity.ConfigKeyTelegramProxyUsername:
 			s.config.ProxyUsername = config.Value
-			utils.Info("[TELEGRAM:CONFIG] 加载配置 %s = %s", config.Key, "[HIDDEN]")
 		case entity.ConfigKeyTelegramProxyPassword:
 			s.config.ProxyPassword = config.Value
-			utils.Info("[TELEGRAM:CONFIG] 加载配置 %s = %s", config.Key, "[HIDDEN]")
 		default:
-			utils.Debug("未知配置: %s = %s", config.Key, config.Value)
+			utils.Debug("未知Telegram配置: %s", config.Key)
 		}
+		configCount++
 	}

-	utils.Info("[TELEGRAM:SERVICE] Telegram Bot 配置加载完成: Enabled=%v, AutoReplyEnabled=%v, ApiKey长度=%d",
-		s.config.Enabled, s.config.AutoReplyEnabled, len(s.config.ApiKey))
+	// 汇总输出配置加载结果，避免逐项日志
+	proxyStatus := "禁用"
+	if s.config.ProxyEnabled {
+		proxyStatus = "启用"
+	}
+
+	utils.TelegramInfo("配置加载完成 - Bot启用: %v, 自动回复: %v, 代理: %s, 配置项数: %d",
+		s.config.Enabled, s.config.AutoReplyEnabled, proxyStatus, configCount)
 	return nil
 }

@@ -185,6 +185,11 @@ func (s *TelegramBotServiceImpl) Start() error {

 	if !s.config.Enabled || s.config.ApiKey == "" {
 		utils.Info("[TELEGRAM:SERVICE] Telegram Bot 未启用或 API Key 未配置")
+		// 如果机器人当前正在运行，需要停止它
+		if s.isRunning {
+			utils.Info("[TELEGRAM:SERVICE] 机器人已被禁用，停止正在运行的服务")
+			s.Stop()
+		}
 		return nil
 	}

@@ -259,6 +264,9 @@ func (s *TelegramBotServiceImpl) Start() error {
 	s.bot = bot
 	s.isRunning = true

+	// 重置停止信号channel
+	s.stopChan = make(chan struct{})
+
 	utils.Info("[TELEGRAM:SERVICE] Telegram Bot (@%s) 已启动", s.GetBotUsername())

 	// 启动推送调度器
@@ -283,6 +291,15 @@ func (s *TelegramBotServiceImpl) Stop() error {

 	s.isRunning = false

+	// 安全地发送停止信号给消息循环
+	select {
+	case <-s.stopChan:
+		// channel 已经关闭
+	default:
+		// channel 未关闭，安全关闭
+		close(s.stopChan)
+	}
+
 	if s.cronScheduler != nil {
 		s.cronScheduler.Stop()
 	}
@@ -514,20 +531,34 @@ func (s *TelegramBotServiceImpl) messageLoop() {

 	utils.Info("[TELEGRAM:MESSAGE] 消息监听循环已启动，等待消息...")

-	for update := range updates {
-		if update.Message != nil {
-			utils.Info("[TELEGRAM:MESSAGE] 接收到新消息更新")
-			s.handleMessage(update.Message)
-		} else {
-			utils.Debug("[TELEGRAM:MESSAGE] 接收到其他类型更新: %v", update)
+	for {
+		select {
+		case <-s.stopChan:
+			utils.Info("[TELEGRAM:MESSAGE] 收到停止信号，退出消息监听循环")
+			return
+		case update, ok := <-updates:
+			if !ok {
+				utils.Info("[TELEGRAM:MESSAGE] updates channel 已关闭，退出消息监听循环")
+				return
+			}
+			if update.Message != nil {
+				utils.Info("[TELEGRAM:MESSAGE] 接收到新消息更新")
+				s.handleMessage(update.Message)
+			} else {
+				utils.Debug("[TELEGRAM:MESSAGE] 接收到其他类型更新: %v", update)
+			}
 		}
 	}
-
-	utils.Info("[TELEGRAM:MESSAGE] 消息监听循环已结束")
 }

 // handleMessage 处理接收到的消息
 func (s *TelegramBotServiceImpl) handleMessage(message *tgbotapi.Message) {
+	// 检查机器人是否正在运行且已启用
+	if !s.isRunning || !s.config.Enabled {
+		utils.Info("[TELEGRAM:MESSAGE] 机器人已停止或禁用，跳过消息处理: ChatID=%d", message.Chat.ID)
+		return
+	}
+
 	chatID := message.Chat.ID
 	text := strings.TrimSpace(message.Text)

@@ -965,8 +996,17 @@ func (s *TelegramBotServiceImpl) pushToChannel(channel entity.TelegramChannel) {

 	// 5. 记录推送的资源ID到历史记录，避免重复推送
 	for _, resource := range resources {
-		resourceEntity := resource.(entity.Resource)
-		s.addPushedResourceID(channel.ChatID, resourceEntity.ID)
+		var resourceID uint
+		switch r := resource.(type) {
+		case *entity.Resource:
+			resourceID = r.ID
+		case entity.Resource:
+			resourceID = r.ID
+		default:
+			utils.Error("[TELEGRAM:PUSH] 无效的资源类型: %T", resource)
+			continue
+		}
+		s.addPushedResourceID(channel.ChatID, resourceID)
 	}

 	utils.Info("[TELEGRAM:PUSH:SUCCESS] 成功推送内容到频道: %s (%d 条资源)", channel.ChatName, len(resources))
@@ -1033,7 +1073,7 @@ func (s *TelegramBotServiceImpl) findLatestResources(channel entity.TelegramChan

 	// 返回最新资源（第一条）
 	utils.Info("[TELEGRAM:PUSH] 成功获取最新资源: %s", resources[0].Title)
-	return []interface{}{resources[0]}
+	return []interface{}{&resources[0]}
 }

 // findTransferredResources 查找已转存资源
@@ -1068,7 +1108,7 @@ func (s *TelegramBotServiceImpl) findTransferredResources(channel entity.Telegra

 	// 返回第一个有转存链接的资源
 	utils.Info("[TELEGRAM:PUSH] 成功获取已转存资源: %s", resources[0].Title)
-	return []interface{}{resources[0]}
+	return []interface{}{&resources[0]}
 }

 // findRandomResources 查找随机资源（原有逻辑）
@@ -1108,7 +1148,7 @@ func (s *TelegramBotServiceImpl) findRandomResources(channel entity.TelegramChan

 		utils.Info("[TELEGRAM:PUSH] 成功获取随机资源: %s (从 %d 个候选资源中选择)",
 			selectedResource.Title, len(candidateResources))
-		return []interface{}{selectedResource}
+		return []interface{}{&selectedResource}
 	}

 	// 如果候选资源不足，回退到数据库随机函数
@@ -1184,7 +1224,18 @@ func (s *TelegramBotServiceImpl) buildFilterParams(channel entity.TelegramChanne

 // buildPushMessage 构建推送消息
 func (s *TelegramBotServiceImpl) buildPushMessage(channel entity.TelegramChannel, resources []interface{}) (string, string) {
-	resource := resources[0].(entity.Resource)
+	var resource *entity.Resource
+
+	// 处理两种可能的类型：*entity.Resource 或 entity.Resource
+	switch r := resources[0].(type) {
+	case *entity.Resource:
+		resource = r
+	case entity.Resource:
+		resource = &r
+	default:
+		utils.Error("[TELEGRAM:PUSH] 无效的资源类型: %T", resources[0])
+		return "", ""
+	}

 	message := fmt.Sprintf("🆕 <b>%s</b>\n", s.cleanMessageTextForHTML(resource.Title))

@@ -1243,6 +1294,12 @@ func (s *TelegramBotServiceImpl) GetBotUsername() string {

 // SendMessage 发送消息（默认使用 HTML 格式）
 func (s *TelegramBotServiceImpl) SendMessage(chatID int64, text string, img string) error {
+	// 检查机器人是否正在运行且已启用
+	if !s.isRunning || !s.config.Enabled {
+		utils.Info("[TELEGRAM:MESSAGE] 机器人已停止或禁用，跳过发送消息: ChatID=%d", chatID)
+		return fmt.Errorf("机器人已停止或禁用")
+	}
+
 	if img == "" {
 		msg := tgbotapi.NewMessage(chatID, text)
 		msg.ParseMode = "HTML"
--- a/task/task_processor.go
+++ b/task/task_processor.go
@@ -189,12 +189,22 @@ func (tm *TaskManager) StopTask(taskID uint) error {
 // processTask 处理任务
 func (tm *TaskManager) processTask(ctx context.Context, task *entity.Task, processor TaskProcessor) {
 	startTime := utils.GetCurrentTime()
+
+	// 记录任务开始
+	utils.Info("任务开始 - ID: %d, 类型: %s", task.ID, task.Type)
+
 	defer func() {
 		tm.mu.Lock()
 		delete(tm.running, task.ID)
 		tm.mu.Unlock()
+
 		elapsedTime := time.Since(startTime)
-		utils.Info("processTask: 任务 %d 处理完成，耗时: %v，清理资源", task.ID, elapsedTime)
+		// 使用业务事件记录任务完成，只有异常情况才输出详细日志
+		if elapsedTime > 30*time.Second {
+			utils.Warn("任务处理耗时较长 - ID: %d, 类型: %s, 耗时: %v", task.ID, task.Type, elapsedTime)
+		}
+
+		utils.Info("任务完成 - ID: %d, 类型: %s, 耗时: %v", task.ID, task.Type, elapsedTime)
 	}()

 	utils.InfoWithFields(map[string]interface{}{
--- a/utils/logger.go
+++ b/utils/logger.go
@@ -1,7 +1,6 @@
 package utils

 import (
-	"encoding/json"
 	"fmt"
 	"io"
 	"log"
@@ -10,7 +9,6 @@ import (
 	"runtime"
 	"strings"
 	"sync"
-	"time"
 )

 // LogLevel 日志级别
@@ -24,7 +22,7 @@ const (
 	FATAL
 )

-// String 返回日志级别的字符串表示
+// String 返回级别的字符串表示
 func (l LogLevel) String() string {
 	switch l {
 	case DEBUG:
@@ -42,280 +40,76 @@ func (l LogLevel) String() string {
 	}
 }

-// StructuredLogEntry 结构化日志条目
-type StructuredLogEntry struct {
-	Timestamp time.Time         `json:"timestamp"`
-	Level     string            `json:"level"`
-	Message   string            `json:"message"`
-	Caller    string            `json:"caller"`
-	Module    string            `json:"module"`
-	Fields    map[string]interface{} `json:"fields,omitempty"`
-}
-
-// Logger 统一日志器
+// Logger 简化的日志器
 type Logger struct {
-	debugLogger *log.Logger
-	infoLogger  *log.Logger
-	warnLogger  *log.Logger
-	errorLogger *log.Logger
-	fatalLogger *log.Logger
-
+	level  LogLevel
+	logger *log.Logger
 	file   *os.File
-	mu     sync.Mutex
-	config *LogConfig
-}
-
-// LogConfig 日志配置
-type LogConfig struct {
-	LogDir         string   // 日志目录
-	LogLevel       LogLevel // 日志级别
-	MaxFileSize    int64    // 单个日志文件最大大小（MB）
-	MaxBackups     int      // 最大备份文件数
-	MaxAge         int      // 日志文件最大保留天数
-	EnableConsole  bool     // 是否启用控制台输出
-	EnableFile     bool     // 是否启用文件输出
-	EnableRotation bool     // 是否启用日志轮转
-	StructuredLog  bool     // 是否启用结构化日志格式
-}
-
-// DefaultConfig 默认配置
-func DefaultConfig() *LogConfig {
-	// 从环境变量获取日志级别，默认为INFO
-	logLevel := getLogLevelFromEnv()
-
-	return &LogConfig{
-		LogDir:         "logs",
-		LogLevel:       logLevel,
-		MaxFileSize:    100, // 100MB
-		MaxBackups:     5,
-		MaxAge:         30, // 30天
-		EnableConsole:  true,
-		EnableFile:     true,
-		EnableRotation: true,
-		StructuredLog:  os.Getenv("STRUCTURED_LOG") == "true", // 从环境变量控制结构化日志
-	}
-}
-
-// getLogLevelFromEnv 从环境变量获取日志级别
-func getLogLevelFromEnv() LogLevel {
-	envLogLevel := os.Getenv("LOG_LEVEL")
-	envDebug := os.Getenv("DEBUG")
-
-	// 如果设置了DEBUG环境变量为true，则使用DEBUG级别
-	if envDebug == "true" || envDebug == "1" {
-		return DEBUG
-	}
-
-	// 根据LOG_LEVEL环境变量设置日志级别
-	switch strings.ToUpper(envLogLevel) {
-	case "DEBUG":
-		return DEBUG
-	case "INFO":
-		return INFO
-	case "WARN", "WARNING":
-		return WARN
-	case "ERROR":
-		return ERROR
-	case "FATAL":
-		return FATAL
-	default:
-		// 根据运行环境设置默认级别：开发环境DEBUG，生产环境INFO
-		if isDevelopment() {
-			return DEBUG
-		}
-		return INFO
-	}
-}
-
-// isDevelopment 判断是否为开发环境
-func isDevelopment() bool {
-	env := os.Getenv("GO_ENV")
-	return env == "development" || env == "dev" || env == "local" || env == "test"
-}
-
-// getEnvironment 获取当前环境类型
-func (l *Logger) getEnvironment() string {
-	if isDevelopment() {
-		return "development"
-	}
-	return "production"
+	mu     sync.RWMutex
 }

 var (
 	globalLogger *Logger
-	onceLogger   sync.Once
+	loggerOnce   sync.Once
 )

-// InitLogger 初始化全局日志器
-func InitLogger(config *LogConfig) error {
+// InitLogger 初始化日志器
+func InitLogger() error {
 	var err error
-	onceLogger.Do(func() {
-		if config == nil {
-			config = DefaultConfig()
+	loggerOnce.Do(func() {
+		globalLogger = &Logger{
+			level:  INFO,
+			logger: log.New(os.Stdout, "", log.LstdFlags),
 		}

-		globalLogger, err = NewLogger(config)
+		// 创建日志目录
+		logDir := "logs"
+		if err = os.MkdirAll(logDir, 0755); err != nil {
+			return
+		}
+
+		// 创建日志文件
+		logFile := filepath.Join(logDir, "app.log")
+		globalLogger.file, err = os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
+		if err != nil {
+			return
+		}
+
+		// 同时输出到控制台和文件
+		globalLogger.logger = log.New(io.MultiWriter(os.Stdout, globalLogger.file), "", log.LstdFlags)
 	})
+
 	return err
 }

 // GetLogger 获取全局日志器
 func GetLogger() *Logger {
 	if globalLogger == nil {
-		InitLogger(nil)
+		InitLogger()
 	}
 	return globalLogger
 }

-// NewLogger 创建新的日志器
-func NewLogger(config *LogConfig) (*Logger, error) {
-	if config == nil {
-		config = DefaultConfig()
-	}
-
-	logger := &Logger{
-		config: config,
-	}
-
-	// 创建日志目录
-	if config.EnableFile {
-		if err := os.MkdirAll(config.LogDir, 0755); err != nil {
-			return nil, fmt.Errorf("创建日志目录失败: %v", err)
-		}
-	}
-
-	// 初始化日志文件
-	if err := logger.initLogFile(); err != nil {
-		return nil, err
-	}
-
-	// 初始化日志器
-	logger.initLoggers()
-
-	// 启动日志轮转检查
-	if config.EnableRotation {
-		go logger.startRotationCheck()
-	}
-
-	// 打印日志配置信息
-	logger.Info("日志系统初始化完成 - 级别: %s, 环境: %s",
-		config.LogLevel.String(),
-		logger.getEnvironment())
-
-	return logger, nil
-}
-
-// initLogFile 初始化日志文件
-func (l *Logger) initLogFile() error {
-	if !l.config.EnableFile {
-		return nil
-	}
-
-	l.mu.Lock()
-	defer l.mu.Unlock()
-
-	// 关闭现有文件
-	if l.file != nil {
-		l.file.Close()
-	}
-
-	// 创建新的日志文件
-	logFile := filepath.Join(l.config.LogDir, fmt.Sprintf("app_%s.log", GetCurrentTime().Format("2006-01-02")))
-	file, err := os.OpenFile(logFile, os.O_CREATE|os.O_WRONLY|os.O_APPEND, 0666)
-	if err != nil {
-		return fmt.Errorf("创建日志文件失败: %v", err)
-	}
-
-	l.file = file
-	return nil
-}
-
-// initLoggers 初始化各个级别的日志器
-func (l *Logger) initLoggers() {
-	var writers []io.Writer
-
-	// 添加控制台输出
-	if l.config.EnableConsole {
-		writers = append(writers, os.Stdout)
-	}
-
-	// 添加文件输出
-	if l.config.EnableFile && l.file != nil {
-		writers = append(writers, l.file)
-	}
-
-	multiWriter := io.MultiWriter(writers...)
-
-	// 创建各个级别的日志器
-	l.debugLogger = log.New(multiWriter, "[DEBUG] ", log.LstdFlags)
-	l.infoLogger = log.New(multiWriter, "[INFO] ", log.LstdFlags)
-	l.warnLogger = log.New(multiWriter, "[WARN] ", log.LstdFlags)
-	l.errorLogger = log.New(multiWriter, "[ERROR] ", log.LstdFlags)
-	l.fatalLogger = log.New(multiWriter, "[FATAL] ", log.LstdFlags)
-}
-
 // log 内部日志方法
 func (l *Logger) log(level LogLevel, format string, args ...interface{}) {
-	if level < l.config.LogLevel {
+	if level < l.level {
 		return
 	}

 	// 获取调用者信息
 	_, file, line, ok := runtime.Caller(2)
-	if !ok {
-		file = "unknown"
-		line = 0
+	caller := "unknown"
+	if ok {
+		caller = fmt.Sprintf("%s:%d", filepath.Base(file), line)
 	}

-	// 提取文件名作为模块名
-	fileName := filepath.Base(file)
-	moduleName := strings.TrimSuffix(fileName, filepath.Ext(fileName))
-
-	// 格式化消息
 	message := fmt.Sprintf(format, args...)
+	logMessage := fmt.Sprintf("[%s] [%s] %s", level.String(), caller, message)

-	// 添加调用位置信息
-	caller := fmt.Sprintf("%s:%d", fileName, line)
+	l.logger.Println(logMessage)

-	if l.config.StructuredLog {
-		// 结构化日志格式
-		entry := StructuredLogEntry{
-			Timestamp: GetCurrentTime(),
-			Level:     level.String(),
-			Message:   message,
-			Caller:    caller,
-			Module:    moduleName,
-		}
-
-		jsonBytes, err := json.Marshal(entry)
-		if err != nil {
-			// 如果JSON序列化失败，回退到普通格式
-			fullMessage := fmt.Sprintf("[%s] [%s:%d] %s", level.String(), fileName, line, message)
-			l.logToLevel(level, fullMessage)
-			return
-		}
-
-		l.logToLevel(level, string(jsonBytes))
-	} else {
-		// 普通文本格式
-		fullMessage := fmt.Sprintf("[%s] [%s:%d] %s", level.String(), fileName, line, message)
-		l.logToLevel(level, fullMessage)
-	}
-}
-
-// logToLevel 根据级别输出日志
-func (l *Logger) logToLevel(level LogLevel, message string) {
-	switch level {
-	case DEBUG:
-		l.debugLogger.Println(message)
-	case INFO:
-		l.infoLogger.Println(message)
-	case WARN:
-		l.warnLogger.Println(message)
-	case ERROR:
-		l.errorLogger.Println(message)
-	case FATAL:
-		l.fatalLogger.Println(message)
+	// Fatal级别终止程序
+	if level == FATAL {
 		os.Exit(1)
 	}
 }
@@ -345,162 +139,72 @@ func (l *Logger) Fatal(format string, args ...interface{}) {
 	l.log(FATAL, format, args...)
 }

-// startRotationCheck 启动日志轮转检查
-func (l *Logger) startRotationCheck() {
-	ticker := time.NewTicker(1 * time.Hour) // 每小时检查一次
-	defer ticker.Stop()
-
-	for range ticker.C {
-		l.checkRotation()
-	}
+// TelegramDebug Telegram调试日志
+func (l *Logger) TelegramDebug(format string, args ...interface{}) {
+	l.log(DEBUG, "[TELEGRAM] "+format, args...)
 }

-// checkRotation 检查是否需要轮转日志
-func (l *Logger) checkRotation() {
-	if !l.config.EnableFile || l.file == nil {
-		return
-	}
-
-	// 检查文件大小
-	fileInfo, err := l.file.Stat()
-	if err != nil {
-		return
-	}
-
-	// 如果文件超过最大大小，进行轮转
-	if fileInfo.Size() > l.config.MaxFileSize*1024*1024 {
-		l.rotateLog()
-	}
-
-	// 清理旧日志文件
-	l.cleanOldLogs()
+// TelegramInfo Telegram信息日志
+func (l *Logger) TelegramInfo(format string, args ...interface{}) {
+	l.log(INFO, "[TELEGRAM] "+format, args...)
 }

-// rotateLog 轮转日志文件
-func (l *Logger) rotateLog() {
+// TelegramWarn Telegram警告日志
+func (l *Logger) TelegramWarn(format string, args ...interface{}) {
+	l.log(WARN, "[TELEGRAM] "+format, args...)
+}
+
+// TelegramError Telegram错误日志
+func (l *Logger) TelegramError(format string, args ...interface{}) {
+	l.log(ERROR, "[TELEGRAM] "+format, args...)
+}
+
+// DebugWithFields 带字段的调试日志
+func (l *Logger) DebugWithFields(fields map[string]interface{}, format string, args ...interface{}) {
+	message := fmt.Sprintf(format, args...)
+	if len(fields) > 0 {
+		var fieldStrs []string
+		for k, v := range fields {
+			fieldStrs = append(fieldStrs, fmt.Sprintf("%s=%v", k, v))
+		}
+		message = fmt.Sprintf("%s [%s]", message, strings.Join(fieldStrs, ", "))
+	}
+	l.log(DEBUG, message)
+}
+
+// InfoWithFields 带字段的信息日志
+func (l *Logger) InfoWithFields(fields map[string]interface{}, format string, args ...interface{}) {
+	message := fmt.Sprintf(format, args...)
+	if len(fields) > 0 {
+		var fieldStrs []string
+		for k, v := range fields {
+			fieldStrs = append(fieldStrs, fmt.Sprintf("%s=%v", k, v))
+		}
+		message = fmt.Sprintf("%s [%s]", message, strings.Join(fieldStrs, ", "))
+	}
+	l.log(INFO, message)
+}
+
+// ErrorWithFields 带字段的错误日志
+func (l *Logger) ErrorWithFields(fields map[string]interface{}, format string, args ...interface{}) {
+	message := fmt.Sprintf(format, args...)
+	if len(fields) > 0 {
+		var fieldStrs []string
+		for k, v := range fields {
+			fieldStrs = append(fieldStrs, fmt.Sprintf("%s=%v", k, v))
+		}
+		message = fmt.Sprintf("%s [%s]", message, strings.Join(fieldStrs, ", "))
+	}
+	l.log(ERROR, message)
+}
+
+// Close 关闭日志文件
+func (l *Logger) Close() {
 	l.mu.Lock()
 	defer l.mu.Unlock()
-
-	// 关闭当前文件
 	if l.file != nil {
 		l.file.Close()
 	}
-
-	// 重命名当前日志文件
-	currentLogFile := filepath.Join(l.config.LogDir, fmt.Sprintf("app_%s.log", GetCurrentTime().Format("2006-01-02")))
-	backupLogFile := filepath.Join(l.config.LogDir, fmt.Sprintf("app_%s_%s.log", GetCurrentTime().Format("2006-01-02"), GetCurrentTime().Format("15-04-05")))
-
-	if _, err := os.Stat(currentLogFile); err == nil {
-		os.Rename(currentLogFile, backupLogFile)
-	}
-
-	// 创建新的日志文件
-	l.initLogFile()
-	l.initLoggers()
-}
-
-// cleanOldLogs 清理旧日志文件
-func (l *Logger) cleanOldLogs() {
-	if l.config.MaxAge <= 0 {
-		return
-	}
-
-	files, err := filepath.Glob(filepath.Join(l.config.LogDir, "app_*.log"))
-	if err != nil {
-		return
-	}
-
-	cutoffTime := GetCurrentTime().AddDate(0, 0, -l.config.MaxAge)
-
-	for _, file := range files {
-		fileInfo, err := os.Stat(file)
-		if err != nil {
-			continue
-		}
-
-		if fileInfo.ModTime().Before(cutoffTime) {
-			os.Remove(file)
-		}
-	}
-}
-
-// Min 返回两个整数中的较小值
-func Min(a, b int) int {
-	if a < b {
-		return a
-	}
-	return b
-}
-
-// 结构化日志方法
-func (l *Logger) DebugWithFields(fields map[string]interface{}, format string, args ...interface{}) {
-	l.logWithFields(DEBUG, fields, format, args...)
-}
-
-func (l *Logger) InfoWithFields(fields map[string]interface{}, format string, args ...interface{}) {
-	l.logWithFields(INFO, fields, format, args...)
-}
-
-func (l *Logger) WarnWithFields(fields map[string]interface{}, format string, args ...interface{}) {
-	l.logWithFields(WARN, fields, format, args...)
-}
-
-func (l *Logger) ErrorWithFields(fields map[string]interface{}, format string, args ...interface{}) {
-	l.logWithFields(ERROR, fields, format, args...)
-}
-
-func (l *Logger) FatalWithFields(fields map[string]interface{}, format string, args ...interface{}) {
-	l.logWithFields(FATAL, fields, format, args...)
-}
-
-// logWithFields 带字段的结构化日志方法
-func (l *Logger) logWithFields(level LogLevel, fields map[string]interface{}, format string, args ...interface{}) {
-	if level < l.config.LogLevel {
-		return
-	}
-
-	// 获取调用者信息
-	_, file, line, ok := runtime.Caller(2)
-	if !ok {
-		file = "unknown"
-		line = 0
-	}
-
-	// 提取文件名作为模块名
-	fileName := filepath.Base(file)
-	moduleName := strings.TrimSuffix(fileName, filepath.Ext(fileName))
-
-	// 格式化消息
-	message := fmt.Sprintf(format, args...)
-
-	// 添加调用位置信息
-	caller := fmt.Sprintf("%s:%d", fileName, line)
-
-	if l.config.StructuredLog {
-		// 结构化日志格式
-		entry := StructuredLogEntry{
-			Timestamp: GetCurrentTime(),
-			Level:     level.String(),
-			Message:   message,
-			Caller:    caller,
-			Module:    moduleName,
-			Fields:    fields,
-		}
-
-		jsonBytes, err := json.Marshal(entry)
-		if err != nil {
-			// 如果JSON序列化失败，回退到普通格式
-			fullMessage := fmt.Sprintf("[%s] [%s:%d] %s - Fields: %v", level.String(), fileName, line, message, fields)
-			l.logToLevel(level, fullMessage)
-			return
-		}
-
-		l.logToLevel(level, string(jsonBytes))
-	} else {
-		// 普通文本格式
-		fullMessage := fmt.Sprintf("[%s] [%s:%d] %s - Fields: %v", level.String(), fileName, line, message, fields)
-		l.logToLevel(level, fullMessage)
-	}
 }

 // 全局便捷函数
@@ -524,7 +228,22 @@ func Fatal(format string, args ...interface{}) {
 	GetLogger().Fatal(format, args...)
 }

-// 全局结构化日志便捷函数
+func TelegramDebug(format string, args ...interface{}) {
+	GetLogger().TelegramDebug(format, args...)
+}
+
+func TelegramInfo(format string, args ...interface{}) {
+	GetLogger().TelegramInfo(format, args...)
+}
+
+func TelegramWarn(format string, args ...interface{}) {
+	GetLogger().TelegramWarn(format, args...)
+}
+
+func TelegramError(format string, args ...interface{}) {
+	GetLogger().TelegramError(format, args...)
+}
+
 func DebugWithFields(fields map[string]interface{}, format string, args ...interface{}) {
 	GetLogger().DebugWithFields(fields, format, args...)
 }
@@ -533,14 +252,15 @@ func InfoWithFields(fields map[string]interface{}, format string, args ...interf
 	GetLogger().InfoWithFields(fields, format, args...)
 }

-func WarnWithFields(fields map[string]interface{}, format string, args ...interface{}) {
-	GetLogger().WarnWithFields(fields, format, args...)
-}
-
 func ErrorWithFields(fields map[string]interface{}, format string, args ...interface{}) {
 	GetLogger().ErrorWithFields(fields, format, args...)
 }

-func FatalWithFields(fields map[string]interface{}, format string, args ...interface{}) {
-	GetLogger().FatalWithFields(fields, format, args...)
+// Min 返回两个整数中的较小值
+func Min(a, b int) int {
+	if a < b {
+		return a
+	}
+	return b
 }
+
--- a/web/composables/useApi.ts
+++ b/web/composables/useApi.ts
@@ -96,7 +96,8 @@ export const useCksApi = () => {
  const updateCks = (id: number, data: any) => useApiFetch(`/cks/${id}`, { method: 'PUT', body: data }).then(parseApiResponse)
  const deleteCks = (id: number) => useApiFetch(`/cks/${id}`, { method: 'DELETE' }).then(parseApiResponse)
  const refreshCapacity = (id: number) => useApiFetch(`/cks/${id}/refresh-capacity`, { method: 'POST' }).then(parseApiResponse)
-  return { getCks, getCksByID, createCks, updateCks, deleteCks, refreshCapacity }
+  const deleteRelatedResources = (id: number) => useApiFetch(`/cks/${id}/delete-related-resources`, { method: 'POST' }).then(parseApiResponse)
+  return { getCks, getCksByID, createCks, updateCks, deleteCks, refreshCapacity, deleteRelatedResources }
 }

 export const useTagApi = () => {
--- a/web/composables/useVersion.ts
+++ b/web/composables/useVersion.ts
@@ -18,7 +18,7 @@ interface VersionResponse {

 export const useVersion = () => {
  const versionInfo = ref<VersionInfo>({
-    version: '1.3.3',
+    version: '1.3.4',
    build_time: '',
    git_commit: 'unknown',
    git_branch: 'unknown',
--- a/web/layouts/default.vue
+++ b/web/layouts/default.vue
@@ -64,10 +64,11 @@ const injectRawScript = (rawScriptString: string) => {
    const container = document.createElement('div');
    container.innerHTML = rawScriptString.trim();

-    // 获取解析后的 script 元素
-    const script = container.querySelector('script');
+    // 获取解析后的所有 script 元素
+    const scripts = container.querySelectorAll('script');

-    if (script) {
+    // 遍历并注入所有脚本
+    scripts.forEach((script) => {
      // 创建新的 script 元素
      const newScript = document.createElement('script');

@@ -83,7 +84,7 @@ const injectRawScript = (rawScriptString: string) => {

      // 插入到 DOM
      document.head.appendChild(newScript);
-    }
+    });
  }
 };

--- a/web/package.json
+++ b/web/package.json
@@ -1,6 +1,6 @@
 {
  "name": "res-db-web",
-  "version": "1.3.3",
+  "version": "1.3.4",
  "private": true,
  "type": "module",
  "scripts": {
--- a/web/pages/admin/accounts.vue
+++ b/web/pages/admin/accounts.vue
@@ -133,6 +133,9 @@
                    <span class="text-xs text-gray-500 dark:text-gray-400">
                      剩余: {{ formatFileSize(Math.max(0, item.left_space)) }}
                    </span>
+                    <span class="text-xs text-gray-500 dark:text-gray-400">
+                      已转存: {{ item.transferred_count || 0 }}
+                    </span>
                  </div>

                  <!-- 备注 -->
@@ -146,25 +149,20 @@
                <!-- 右侧操作按钮 -->
                <div class="flex items-center space-x-2 ml-4">
                  <n-button size="small" :type="item.is_valid ? 'warning' : 'success'" @click="toggleStatus(item)"
-                    :title="item.is_valid ? '禁用账号' : '启用账号'">
-                    <template #icon>
-                      <i :class="item.is_valid ? 'fas fa-ban' : 'fas fa-check'"></i>
-                    </template>
+                    :title="item.is_valid ? '禁用账号' : '启用账号'" text>
+                    {{ item.is_valid ? '禁用' : '启用' }}
                  </n-button>
-                  <n-button size="small" type="info" @click="refreshCapacity(item.id)" title="刷新容量">
-                    <template #icon>
-                      <i class="fas fa-sync-alt"></i>
-                    </template>
+                  <n-button size="small" type="info" @click="refreshCapacity(item.id)" title="刷新容量" text>
+                    刷新容量
                  </n-button>
-                  <n-button size="small" type="primary" @click="editCks(item)" title="编辑账号">
-                    <template #icon>
-                      <i class="fas fa-edit"></i>
-                    </template>
+                  <n-button size="small" type="primary" @click="editCks(item)" title="编辑账号" text>
+                    编辑
                  </n-button>
-                  <n-button size="small" type="error" @click="deleteCks(item.id)" title="删除账号">
-                    <template #icon>
-                      <i class="fas fa-trash"></i>
-                    </template>
+                  <n-button size="small" type="error" @click="deleteCks(item.id)" title="删除账号" text>
+                    删除
+                  </n-button>
+                  <n-button size="small" type="warning" @click="deleteRelatedResources(item.id)" title="删除关联资源" text>
+                    删除关联
                  </n-button>
                </div>
              </div>
@@ -220,10 +218,20 @@
      </div>

      <div v-if="isXunlei">
-        <label class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
-          refresh_token <span class="text-red-500">*</span>
-        </label>
-        <n-input v-model:value="form.ck" type="textarea" placeholder="请输入" :rows="4" required />
+        <div class="space-y-4">
+          <div>
+            <label class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
+              手机号 <span class="text-red-500">*</span>
+            </label>
+            <n-input v-model:value="xunleiForm.username" placeholder="请输入手机号（不需要+86前缀）" required />
+          </div>
+          <div>
+            <label class="block text-sm font-medium text-gray-700 dark:text-gray-300 mb-2">
+              密码 <span class="text-red-500">*</span>
+            </label>
+            <n-input v-model:value="xunleiForm.password" type="password" placeholder="请输入密码" show-password-on="click" required />
+          </div>
+        </div>
      </div>

      <div>
@@ -241,9 +249,15 @@
    <template #footer>
      <div class="flex justify-end space-x-3">
        <n-button type="tertiary" @click="closeModal">
+          <template #icon>
+            <i class="fas fa-times"></i>
+          </template>
          取消
        </n-button>
        <n-button type="primary" :loading="submitting" @click="handleSubmit">
+          <template #icon>
+            <i class="fas fa-check"></i>
+          </template>
          {{ showEditModal ? '更新' : '创建' }}
        </n-button>
      </div>
@@ -276,6 +290,12 @@ const form = ref({
  remark: ''
 })

+// 迅雷专用表单数据
+const xunleiForm = ref({
+  username: '',
+  password: ''
+})
+
 const panEnables = ref(['quark', 'xunlei'])
 // const xunleiEnable = useCookie('xunleiEnable', { default: () => false })
 // if (xunleiEnable.value && xunleiEnable.value === 'true') {
@@ -428,6 +448,36 @@ const deleteCks = async (id) => {
  })
 }

+// 删除关联资源
+const deleteRelatedResources = async (id) => {
+  dialog.warning({
+    title: '警告',
+    content: '确定要删除与此账号关联的所有资源吗？这将清空这些资源的转存信息，变为未转存状态。',
+    positiveText: '确定',
+    negativeText: '取消',
+    draggable: true,
+    onPositiveClick: async () => {
+      try {
+        // 调用API删除关联资源
+        await cksApi.deleteRelatedResources(id)
+        await fetchCks()
+        notification.success({
+          title: '成功',
+          content: '关联资源已删除！',
+          duration: 3000
+        })
+      } catch (error) {
+        console.error('删除关联资源失败:', error)
+        notification.error({
+          title: '失败',
+          content: '删除关联资源失败: ' + (error.message || '未知错误'),
+          duration: 3000
+        })
+      }
+    }
+  })
+}
+
 // 刷新容量
 const refreshCapacity = async (id) => {
  dialog.warning({
@@ -499,6 +549,25 @@ const editCks = (cks) => {
    is_valid: cks.is_valid,
    remark: cks.remark || ''
  }
+
+  // 如果是迅雷账号，解析ck字段来设置表单
+  if (cks.pan?.name === 'xunlei') {
+    try {
+      // 解析JSON格式
+      const parsed = JSON.parse(cks.ck)
+      xunleiForm.value = {
+        username: parsed.username,
+        password: parsed.password
+      }
+    } catch (e) {
+      // 解析失败，清空表单
+      xunleiForm.value = {
+        username: '',
+        password: ''
+      }
+    }
+  }
+
  showEditModal.value = true
 }

@@ -513,10 +582,32 @@ const closeModal = () => {
    is_valid: true,
    remark: ''
  }
+  // 重置迅雷表单
+  xunleiForm.value = {
+    username: '',
+    password: ''
+  }
 }

 // 提交表单
 const handleSubmit = async () => {
+  // 如果是迅雷账号，需要构造账号密码的JSON格式
+  if (isXunlei.value) {
+    if (!xunleiForm.value.username || !xunleiForm.value.password) {
+      notification.error({
+        title: '失败',
+        content: '请填写完整的账号和密码',
+        duration: 3000
+      })
+      return
+    }
+    form.value.ck = JSON.stringify({
+      username: xunleiForm.value.username,
+      password: xunleiForm.value.password,
+      refresh_token: '' // 初始为空，登录后会填充
+    })
+  }
+
  if (showEditModal.value) {
    await updateCks()
  } else {
--- a/web/pages/admin/resources.vue
+++ b/web/pages/admin/resources.vue
@@ -150,6 +150,10 @@
                      <i class="fas fa-eye mr-1"></i>
                      {{ resource.view_count || 0 }}
                    </span>
+                    <span>
+                      <i class="fas fa-clock mr-1"></i>
+                      {{ resource.updated_at }}
+                    </span>
                  </div>

                  <div v-if="resource.tags && resource.tags.length > 0" class="mt-2">
@@ -670,20 +674,20 @@ const handleEditSubmit = async () => {
  try {
    editing.value = true
    await editFormRef.value?.validate()
-    
+
    await resourceApi.updateResource(editingResource.value!.id, editForm.value)
-    
+
    notification.success({
      content: '更新成功',
      duration: 3000
    })
-    
+
    // 更新本地数据
    const resourceId = editingResource.value?.id
    const index = resources.value.findIndex(r => r.id === resourceId)
    if (index > -1) {
-      resources.value[index] = { 
-        ...resources.value[index], 
+      resources.value[index] = {
+        ...resources.value[index],
        title: editForm.value.title,
        description: editForm.value.description,
        url: editForm.value.url,
@@ -692,7 +696,7 @@ const handleEditSubmit = async () => {
        tag_ids: editForm.value.tag_ids
      }
    }
-    
+
    showEditModal.value = false
    editingResource.value = null
  } catch (error) {
--- a/web/stores/systemConfig.ts
+++ b/web/stores/systemConfig.ts
@@ -14,13 +14,13 @@ export const useSystemConfigStore = defineStore('systemConfig', {
        // 根据上下文选择API：管理员页面使用管理员API，其他页面使用公开API
        const apiUrl = useAdminApi ? '/system/config' : '/public/system-config'
        const response = await useApiFetch(apiUrl)
-        console.log('Store API响应:', response) // 调试信息
+        // console.log('Store API响应:', response) // 调试信息
        
        // 使用parseApiResponse正确解析API响应
        const data = parseApiResponse(response)
-        console.log('Store 处理后的数据:', data) // 调试信息
-        console.log('Store 自动处理状态:', data.auto_process_ready_resources)
-        console.log('Store 自动转存状态:', data.auto_transfer_enabled)
+        // console.log('Store 处理后的数据:', data) // 调试信息
+        // console.log('Store 自动处理状态:', data.auto_process_ready_resources)
+        // console.log('Store 自动转存状态:', data.auto_transfer_enabled)
        
        this.config = data
        this.initialized = true
Author	SHA1	Message	Date
ctwj	5b7e7b73ad	update: xunlei	2025-11-11 01:53:11 +08:00
ctwj	ca175ec59d	update: xunlei	2025-11-11 01:36:33 +08:00
Kerwin	ec4e0762d5	update: 迅雷使用账密方式登录	2025-11-10 14:29:28 +08:00
Kerwin	081a3a7222	fix: 修复机器人停止了还能回复消息的问题	2025-11-10 10:51:33 +08:00
ctwj	9333f9da94	fix: 修复多个三方统计只生效一个的问题	2025-11-07 22:35:06 +08:00
Kerwin	806a724fb5	fix: 优化日志	2025-11-07 18:52:27 +08:00
Kerwin	487f5c9559	update: 日志优化	2025-11-07 18:50:08 +08:00
Kerwin	18b7f89c49	update: version 1.3.4	2025-11-06 20:02:29 +08:00
Kerwin	db902f3742	chore: bump version to v1.3.4	2025-11-06 19:09:48 +08:00
Kerwin	42baa891f8	fix: 修复应为推送导致的程序崩溃	2025-11-06 19:07:03 +08:00
Kerwin	02d5d00510	update: 优化平台账号管理	2025-11-05 20:52:32 +08:00
ctwj	d95c69142a	Update README with WeChat auto-reply link Added link for WeChat official account auto-reply.	2025-11-04 16:11:38 +08:00
@@ -1 +1 @@
 .3.3
 .3.4