- {config.UserConfig.Users.length}
+ {!hasOldUserData && usersV2 ? userTotal : displayUsers.length}
总用户数
+
+ )}
{/* 用户组管理 */}
@@ -1163,10 +1289,31 @@ const UserConfig = ({ config, role, refreshConfig }: UserConfigProps) => {
)}
{/* 用户列表 */}
-
+
+
+
+
+ + 检测到旧版用户数据 +
++ 建议迁移到新的用户存储结构，以获得更好的性能和安全性。迁移后用户密码将使用SHA256加密。 +
+
+
{/* 配置用户采集源权限弹窗 */}
@@ -2523,11 +2739,595 @@ const UserConfig = ({ config, role, refreshConfig }: UserConfigProps) => {
message={alertModal.message}
timer={alertModal.timer}
showConfirm={alertModal.showConfirm}
+ onConfirm={alertModal.onConfirm}
/>
);
};
+// 私人影库配置组件
+const OpenListConfigComponent = ({
+ config,
+ refreshConfig,
+}: {
+ config: AdminConfig | null;
+ refreshConfig: () => Promise
+ {/* 迁移遮罩层 */}
+ {config.UserConfig.Users &&
+ config.UserConfig.Users.filter(u => u.role !== 'owner').length > 0 && (
+
+
+ {/* 用户列表分页 */}
+ {!hasOldUserData && usersV2 && userTotalPages > 1 && (
+
+
+ )}
+
+
+
+
+ + 需要迁移数据 +
++ 检测到旧版用户数据，请先迁移到新的存储结构后再进行用户管理操作。 +
++ 请在上方的"用户统计"区域点击"立即迁移"按钮完成数据迁移。 +
+| + 加载中... + | +
{user.username}
- {(user as any).oidcSub && (
+ {user.oidcSub && (
OIDC
@@ -1475,6 +1635,62 @@ const UserConfig = ({ config, role, refreshConfig }: UserConfigProps) => {
})()}
|
+
+ )}
+
+ 共 {userTotal} 个用户，第 {userPage} / {userTotalPages} 页
+
+
+
+
+
+
+
+
+ {/* 使用说明 */}
+
@@ -5242,6 +6058,109 @@ const SiteConfigComponent = ({
+
+ {/* TMDB Proxy */}
+
+
+
+ {/* 功能开关 */}
+
+
+
+ 使用说明
+
+
+
+
+ • 私人影库功能需要配合 OpenList 使用，用于管理和播放您自己的视频文件
+• OpenList 是一个开源的网盘聚合程序，支持多种存储后端（本地、阿里云盘、OneDrive 等）
+• 配置后，系统会自动扫描指定目录下的视频文件夹，并通过 TMDB 匹配元数据信息
+• 定时扫描间隔设置为 0 表示关闭自动扫描，最低间隔为 60 分钟
+• 视频文件夹名称为影片名称，精准命名可以提高 TMDB 匹配准确率
+ +
+
+
+ {/* 配置表单 */}
+
+
+
+ + 启用私人影库功能 +
++ 关闭后将不显示私人影库入口，也不会执行定时扫描 +
+
+
+
+ {/* 视频列表区域 */}
+ {enabled && config?.OpenListConfig?.URL && config?.OpenListConfig?.Username && config?.OpenListConfig?.Password && (
+
+
+ setUrl(e.target.value)}
+ disabled={!enabled}
+ placeholder='https://your-openlist-server.com'
+ className='w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-lg bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 focus:ring-2 focus:ring-blue-500 focus:border-transparent disabled:opacity-50 disabled:cursor-not-allowed'
+ />
+
+
+
+
+
+
+
+ setUsername(e.target.value)}
+ disabled={!enabled}
+ placeholder='admin'
+ className='w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-lg bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 focus:ring-2 focus:ring-blue-500 focus:border-transparent disabled:opacity-50 disabled:cursor-not-allowed'
+ />
+
+
+
+ setPassword(e.target.value)}
+ disabled={!enabled}
+ placeholder='password'
+ className='w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-lg bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 focus:ring-2 focus:ring-blue-500 focus:border-transparent disabled:opacity-50 disabled:cursor-not-allowed'
+ />
+
+
+
+ setRootPath(e.target.value)}
+ disabled={!enabled}
+ placeholder='/'
+ className='w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-lg bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 focus:ring-2 focus:ring-blue-500 focus:border-transparent disabled:opacity-50 disabled:cursor-not-allowed'
+ />
+
+
+ + OpenList 中的视频文件夹路径，默认为根目录 / +
+
+
+ setScanInterval(parseInt(e.target.value) || 0)}
+ disabled={!enabled}
+ placeholder='0'
+ min='0'
+ className='w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-lg bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 focus:ring-2 focus:ring-blue-500 focus:border-transparent disabled:opacity-50 disabled:cursor-not-allowed'
+ />
+
+
+ + 设置为 0 关闭定时扫描，最低 60 分钟 +
+
+
+
+
+
+ setCorrectDialogOpen(false)}
+ folder={selectedVideo.folder}
+ currentTitle={selectedVideo.title}
+ onCorrect={handleCorrectSuccess}
+ />
+ )}
+
+ );
+};
+
// 视频源配置组件
const VideoSourceConfig = ({
config,
@@ -4601,6 +5401,10 @@ const SiteConfigComponent = ({
DanmakuApiBase: 'http://localhost:9321',
DanmakuApiToken: '87654321',
TMDBApiKey: '',
+ TMDBProxy: '',
+ PansouApiUrl: '',
+ PansouUsername: '',
+ PansouPassword: '',
EnableComments: false,
EnableRegistration: false,
RegistrationRequireTurnstile: false,
@@ -4684,6 +5488,10 @@ const SiteConfigComponent = ({
config.SiteConfig.DanmakuApiBase || 'http://localhost:9321',
DanmakuApiToken: config.SiteConfig.DanmakuApiToken || '87654321',
TMDBApiKey: config.SiteConfig.TMDBApiKey || '',
+ TMDBProxy: config.SiteConfig.TMDBProxy || '',
+ PansouApiUrl: config.SiteConfig.PansouApiUrl || '',
+ PansouUsername: config.SiteConfig.PansouUsername || '',
+ PansouPassword: config.SiteConfig.PansouPassword || '',
EnableComments: config.SiteConfig.EnableComments || false,
});
}
@@ -5180,7 +5988,15 @@ const SiteConfigComponent = ({
className='w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-lg bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 focus:ring-2 focus:ring-green-500 focus:border-transparent'
/>
+
+
+ {refreshing && scanProgress && (
+
+
+ + 视频列表 +
+
+ 资源数: {config.OpenListConfig.ResourceCount || 0}
+ |
+
+ 上次更新: {formatDate(config.OpenListConfig.LastRefreshTime)}
+
+
+
+
+
+
+
+
+ )}
+
+
+
+ 扫描进度: {scanProgress.current} / {scanProgress.total}
+
+
+ {scanProgress.total > 0
+ ? Math.round((scanProgress.current / scanProgress.total) * 100)
+ : 0}
+ %
+
+
+
+
+ )}
+
+ {refreshing ? (
+ 0 ? (scanProgress.current / scanProgress.total) * 100 : 0}%`,
+ }}
+ />
+
+ {scanProgress.currentFolder && (
+ + 正在处理: {scanProgress.currentFolder} +
+ )} +
+ 加载中...
+
+ ) : videos.length > 0 ? (
+
+
+
+
+
+ ) : (
+ | + 标题 + | ++ 状态 + | ++ 类型 + | ++ 年份 + | ++ 评分 + | ++ 操作 + | +
|---|---|---|---|---|---|
| + {video.title} + | ++ {video.failed ? ( + + 匹配失败 + + ) : ( + + 正常 + + )} + | ++ {video.mediaType === 'movie' ? '电影' : '剧集'} + | ++ {video.releaseDate ? video.releaseDate.split('-')[0] : '-'} + | ++ {video.voteAverage > 0 ? video.voteAverage.toFixed(1) : '-'} + | +
+
+ {!video.failed && (
+
+ )}
+
+
+
+ |
+
+ 暂无视频，请点击"立即扫描"扫描视频库
+
+ )}
+ - 弹幕服务器的 API 地址，默认为 http://localhost:9321 + 弹幕服务器的 API 地址，默认为 http://localhost:9321。API部署参考 + + danmu_api +
+
+
+ setSiteSettings((prev) => ({
+ ...prev,
+ TMDBProxy: e.target.value,
+ }))
+ }
+ className='w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-lg bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 focus:ring-2 focus:ring-green-500 focus:border-transparent'
+ />
+
+
+
+ {/* Pansou 配置 */}
+ + 配置代理服务器地址，用于访问 TMDB API（可选） +
+
+
{/* 评论功能配置 */}
@@ -6984,6 +7903,7 @@ function AdminPageClient() {
const [expandedTabs, setExpandedTabs] = useState<{ [key: string]: boolean }>({
userConfig: false,
videoSource: false,
+ openListConfig: false,
liveSource: false,
siteConfig: false,
registrationConfig: false,
@@ -7023,17 +7943,67 @@ function AdminPageClient() {
}
}, []);
+ // 新版本用户列表状态
+ const [usersV2, setUsersV2] = useState+ Pansou 网盘搜索配置 +
+ + {/* Pansou API 地址 */} +
+
+
+ setSiteSettings((prev) => ({
+ ...prev,
+ PansouApiUrl: e.target.value,
+ }))
+ }
+ className='w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-lg bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 focus:ring-2 focus:ring-green-500 focus:border-transparent'
+ />
+
+
+ {/* Pansou 账号 */}
+ + 配置 Pansou 服务器地址，用于网盘资源搜索。项目地址：{' '} + + https://github.com/fish2018/pansou + +
+
+
+
+ setSiteSettings((prev) => ({
+ ...prev,
+ PansouUsername: e.target.value,
+ }))
+ }
+ className='w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-lg bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 focus:ring-2 focus:ring-green-500 focus:border-transparent'
+ />
+
+
+ {/* Pansou 密码 */}
+ + 如果 Pansou 服务启用了认证功能，需要提供账号密码 +
+
+
+
+ setSiteSettings((prev) => ({
+ ...prev,
+ PansouPassword: e.target.value,
+ }))
+ }
+ className='w-full px-3 py-2 border border-gray-300 dark:border-gray-600 rounded-lg bg-white dark:bg-gray-800 text-gray-900 dark:text-gray-100 focus:ring-2 focus:ring-green-500 focus:border-transparent'
+ />
+
+ 配置账号密码后，系统会自动登录并缓存 Token +
+
@@ -5107,6 +5226,40 @@ function PlayPageClient() {
});
}}
/>
+
+ {/* 网盘搜索弹窗 */}
+ {showPansouDialog && (
+ ([]);
+ const [loading, setLoading] = useState(true);
+ const [error, setError] = useState('');
+ const [page, setPage] = useState(1);
+ const [totalPages, setTotalPages] = useState(1);
+ const pageSize = 20;
+
+ useEffect(() => {
+ fetchVideos();
+ }, [page]);
+
+ const fetchVideos = async () => {
+ try {
+ setLoading(true);
+ const response = await fetch(
+ `/api/openlist/list?page=${page}&pageSize=${pageSize}`
+ );
+
+ if (!response.ok) {
+ throw new Error('获取视频列表失败');
+ }
+
+ const data = await response.json();
+
+ if (data.error) {
+ setError(data.error);
+ setVideos([]);
+ } else {
+ setVideos(data.list || []);
+ setTotalPages(data.totalPages || 1);
+ }
+ } catch (err) {
+ console.error('获取视频列表失败:', err);
+ setError('获取视频列表失败');
+ setVideos([]);
+ } finally {
+ setLoading(false);
+ }
+ };
+
+ const handleVideoClick = (video: Video) => {
+ // 跳转到播放页面
+ router.push(`/play?source=openlist&id=${encodeURIComponent(video.folder)}`);
+ };
+
+ return (
+
+
+ );
+}
diff --git a/src/app/search/page.tsx b/src/app/search/page.tsx
index e8166fa..f413af9 100644
--- a/src/app/search/page.tsx
+++ b/src/app/search/page.tsx
@@ -18,12 +18,17 @@ import PageLayout from '@/components/PageLayout';
import SearchResultFilter, { SearchFilterCategory } from '@/components/SearchResultFilter';
import SearchSuggestions from '@/components/SearchSuggestions';
import VideoCard, { VideoCardHandle } from '@/components/VideoCard';
+import PansouSearch from '@/components/PansouSearch';
function SearchPageClient() {
// 搜索历史
const [searchHistory, setSearchHistory] = useState([]);
// 返回顶部按钮显示状态
const [showBackToTop, setShowBackToTop] = useState(false);
+ // 选项卡状态: 'video' 或 'pansou'
+ const [activeTab, setActiveTab] = useState<'video' | 'pansou'>('video');
+ // Pansou 搜索触发标志
+ const [triggerPansouSearch, setTriggerPansouSearch] = useState(false);
const router = useRouter();
const searchParams = useSearchParams();
@@ -381,6 +386,14 @@ function SearchPageClient() {
});
}, [aggregatedResults, filterAgg, searchQuery]);
+ // 监听选项卡切换，自动执行搜索
+ useEffect(() => {
+ // 如果切换到网盘搜索选项卡，且有搜索关键词，且已显示结果，则触发搜索
+ if (activeTab === 'pansou' && searchQuery.trim() && showResults) {
+ setTriggerPansouSearch(prev => !prev);
+ }
+ }, [activeTab]);
+
useEffect(() => {
// 无搜索参数时聚焦搜索框
!searchParams.get('q') && document.getElementById('searchInput')?.focus();
@@ -693,8 +706,15 @@ function SearchPageClient() {
setShowResults(true);
setShowSuggestions(false);
- router.push(`/search?q=${encodeURIComponent(trimmed)}`);
- // 其余由 searchParams 变化的 effect 处理
+ // 根据当前选项卡执行不同的搜索
+ if (activeTab === 'video') {
+ // 影视搜索
+ router.push(`/search?q=${encodeURIComponent(trimmed)}`);
+ // 其余由 searchParams 变化的 effect 处理
+ } else if (activeTab === 'pansou') {
+ // 网盘搜索 - 触发搜索
+ setTriggerPansouSearch(prev => !prev); // 切换状态来触发搜索
+ }
};
const handleSuggestionSelect = (suggestion: string) => {
@@ -778,14 +798,41 @@ function SearchPageClient() {
/>
+
+ {/* 选项卡 */}
+ setShowPansouDialog(false)}
+ >
+
+ )}
);
}
diff --git a/src/app/private-library/page.tsx b/src/app/private-library/page.tsx
new file mode 100644
index 0000000..b7fb720
--- /dev/null
+++ b/src/app/private-library/page.tsx
@@ -0,0 +1,148 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, no-console */
+
+'use client';
+
+import { useRouter } from 'next/navigation';
+import { useEffect, useState } from 'react';
+
+import PageLayout from '@/components/PageLayout';
+import VideoCard from '@/components/VideoCard';
+
+interface Video {
+ id: string;
+ folder: string;
+ tmdbId: number;
+ title: string;
+ poster: string;
+ releaseDate: string;
+ overview: string;
+ voteAverage: number;
+ mediaType: 'movie' | 'tv';
+}
+
+export default function PrivateLibraryPage() {
+ const router = useRouter();
+ const [videos, setVideos] = useState e.stopPropagation()}
+ >
+ {/* 弹窗头部 */}
+
+
+
+
+ {/* 弹窗内容 */}
+ + 搜索网盘资源: {detail?.title || ''} +
+ +
+
+
+
+
+
+
+ {error && (
+ + 私人影库 +
++ 观看自我收藏的高清视频吧 +
+
+
+ )}
+
+ {loading ? (
+ {error}
+
+ {Array.from({ length: pageSize }).map((_, index) => (
+
+ ))}
+
+ ) : videos.length === 0 ? (
+
+
+ ) : (
+ <>
+ + 暂无视频，请在管理面板配置 OpenList 并刷新 +
+
+ {videos.map((video) => (
+
+
+ {/* 分页 */}
+ {totalPages > 1 && (
+
+
+
+
+ 第 {page} / {totalPages} 页
+
+
+
+
+ )}
+
+ )}
+
+
+
+
{/* 搜索结果或搜索历史 */}
{showResults ? (
- {/* 标题 */}
- = {
+ baidu: '百度网盘',
+ aliyun: '阿里云盘',
+ quark: '夸克网盘',
+ tianyi: '天翼云盘',
+ uc: 'UC网盘',
+ mobile: '移动云盘',
+ '115': '115网盘',
+ pikpak: 'PikPak',
+ xunlei: '迅雷网盘',
+ '123': '123网盘',
+ magnet: '磁力链接',
+ ed2k: '电驴链接',
+ others: '其他',
+};
+
+// 网盘类型颜色
+const CLOUD_TYPE_COLORS: Record = {
+ baidu: 'bg-blue-100 text-blue-800 dark:bg-blue-900/40 dark:text-blue-200',
+ aliyun: 'bg-orange-100 text-orange-800 dark:bg-orange-900/40 dark:text-orange-200',
+ quark: 'bg-purple-100 text-purple-800 dark:bg-purple-900/40 dark:text-purple-200',
+ tianyi: 'bg-red-100 text-red-800 dark:bg-red-900/40 dark:text-red-200',
+ uc: 'bg-green-100 text-green-800 dark:bg-green-900/40 dark:text-green-200',
+ mobile: 'bg-pink-100 text-pink-800 dark:bg-pink-900/40 dark:text-pink-200',
+ '115': 'bg-yellow-100 text-yellow-800 dark:bg-yellow-900/40 dark:text-yellow-200',
+ pikpak: 'bg-indigo-100 text-indigo-800 dark:bg-indigo-900/40 dark:text-indigo-200',
+ xunlei: 'bg-cyan-100 text-cyan-800 dark:bg-cyan-900/40 dark:text-cyan-200',
+ '123': 'bg-teal-100 text-teal-800 dark:bg-teal-900/40 dark:text-teal-200',
+ magnet: 'bg-gray-100 text-gray-800 dark:bg-gray-700/40 dark:text-gray-200',
+ ed2k: 'bg-gray-100 text-gray-800 dark:bg-gray-700/40 dark:text-gray-200',
+ others: 'bg-gray-100 text-gray-800 dark:bg-gray-700/40 dark:text-gray-200',
+};
+
+export default function PansouSearch({
+ keyword,
+ triggerSearch,
+ onError,
+}: PansouSearchProps) {
+ const [loading, setLoading] = useState(false);
+ const [results, setResults] = useState(null);
+ const [error, setError] = useState(null);
+ const [copiedUrl, setCopiedUrl] = useState(null);
+ const [selectedType, setSelectedType] = useState('all'); // 'all' 表示显示全部
+
+ useEffect(() => {
+ // 只在 triggerSearch 变化时执行搜索，不响应 keyword 变化
+ if (!triggerSearch) {
+ return;
+ }
+
+ const currentKeyword = keyword.trim();
+ if (!currentKeyword) {
+ return;
+ }
+
+ const searchPansou = async () => {
+ setLoading(true);
+ setError(null);
+ setResults(null);
+
+ try {
+ const response = await fetch('/api/pansou/search', {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ },
+ body: JSON.stringify({
+ keyword: currentKeyword,
+ }),
+ });
+
+ if (!response.ok) {
+ const errorData = await response.json();
+ throw new Error(errorData.error || '搜索失败');
+ }
+
+ const data: PansouSearchResult = await response.json();
+ setResults(data);
+ } catch (err: any) {
+ const errorMsg = err.message || '搜索失败，请检查配置';
+ setError(errorMsg);
+ onError?.(errorMsg);
+ } finally {
+ setLoading(false);
+ }
+ };
+
+ searchPansou();
+ }, [triggerSearch, onError]); // 移除 keyword 依赖，只依赖 triggerSearch
+
+ const handleCopy = async (text: string, url: string) => {
+ try {
+ await navigator.clipboard.writeText(text);
+ setCopiedUrl(url);
+ setTimeout(() => setCopiedUrl(null), 2000);
+ } catch (err) {
+ console.error('复制失败:', err);
+ }
+ };
+
+ const handleOpenLink = (url: string) => {
+ window.open(url, '_blank', 'noopener,noreferrer');
+ };
+
+ if (loading) {
+ return (
+
+ {/* 禁用弹幕热力 */}
+
+ {activeTab === 'video' ? (
+ <>
+ {/* 影视搜索结果 */}
+ {/* 标题 */}
+
)}
+
+ ) : (
+ <>
+ {/* 网盘搜索结果 */}
+
{/* 重新测试按钮 */}
{(() => {
+ // 私人影库不显示重新测试按钮
+ if (source.source === 'openlist') {
+ return null;
+ }
+
const sourceKey = `${source.source}-${source.id}`;
const isTesting = retestingSources.has(sourceKey);
const videoInfo = videoInfoMap.get(sourceKey);
diff --git a/src/components/MobileBottomNav.tsx b/src/components/MobileBottomNav.tsx
index 3b15fe3..ed74e9c 100644
--- a/src/components/MobileBottomNav.tsx
+++ b/src/components/MobileBottomNav.tsx
@@ -2,7 +2,7 @@
'use client';
-import { Cat, Clover, Film, Home, Radio, Star, Tv, Users } from 'lucide-react';
+import { Cat, Clover, Film, FolderOpen, Home, Radio, Star, Tv, Users } from 'lucide-react';
import Link from 'next/link';
import { usePathname, useSearchParams } from 'next/navigation';
import { useEffect, useState } from 'react';
@@ -90,6 +90,15 @@ const MobileBottomNav = ({ activePath }: MobileBottomNavProps) => {
},
];
+ // 如果配置了 OpenList，添加私人影库入口
+ if (runtimeConfig?.OPENLIST_ENABLED) {
+ items.push({
+ icon: FolderOpen,
+ label: '私人影库',
+ href: '/private-library',
+ });
+ }
+
// 如果启用观影室，添加观影室入口
if (watchRoomContext?.isEnabled) {
items.push({
diff --git a/src/components/PansouSearch.tsx b/src/components/PansouSearch.tsx
new file mode 100644
index 0000000..db0b702
--- /dev/null
+++ b/src/components/PansouSearch.tsx
@@ -0,0 +1,314 @@
+/* eslint-disable @typescript-eslint/no-explicit-any,no-console */
+'use client';
+
+import { AlertCircle, Copy, ExternalLink, Loader2 } from 'lucide-react';
+import { useEffect, useState } from 'react';
+
+import { PansouLink, PansouSearchResult } from '@/lib/pansou.client';
+
+interface PansouSearchProps {
+ keyword: string;
+ triggerSearch?: boolean; // 触发搜索的标志
+ onError?: (error: string) => void;
+}
+
+// 网盘类型映射
+const CLOUD_TYPE_NAMES: Record搜索结果 {isFromCache ? ( @@ -930,6 +977,21 @@ function SearchPageClient() { ))}
+
+ + 网盘搜索结果 +
+
+
+ );
+ }
+
+ if (error) {
+ return (
+
+
+ + 正在搜索网盘资源... +
+
+
+ );
+ }
+
+ if (!results || results.total === 0 || !results.merged_by_type) {
+ return (
+
+
+ {error}
+
+
+ );
+ }
+
+ const cloudTypes = Object.keys(results.merged_by_type || {});
+
+ // 过滤显示的网盘类型
+ const filteredCloudTypes = selectedType === 'all'
+ ? cloudTypes
+ : cloudTypes.filter(type => type === selectedType);
+
+ // 计算每种网盘类型的数量
+ const typeStats = cloudTypes.map(type => ({
+ type,
+ count: results.merged_by_type?.[type]?.length || 0,
+ }));
+
+ return (
+
+
+ + 未找到相关资源 +
+
+ {/* 搜索结果统计 */}
+
+ );
+}
diff --git a/src/components/Sidebar.tsx b/src/components/Sidebar.tsx
index 12552e4..78a6d4a 100644
--- a/src/components/Sidebar.tsx
+++ b/src/components/Sidebar.tsx
@@ -2,7 +2,7 @@
'use client';
-import { Cat, Clover, Film, Home, Menu, Radio, Search, Star, Tv, Users } from 'lucide-react';
+import { Cat, Clover, Film, FolderOpen, Home, Menu, Radio, Search, Star, Tv, Users } from 'lucide-react';
import Link from 'next/link';
import { usePathname, useSearchParams } from 'next/navigation';
import {
@@ -179,6 +179,15 @@ const Sidebar = ({ onToggle, activePath = '/' }: SidebarProps) => {
},
];
+ // 如果配置了 OpenList，添加私人影库入口
+ if (runtimeConfig?.OPENLIST_ENABLED) {
+ items.push({
+ icon: FolderOpen,
+ label: '私人影库',
+ href: '/private-library',
+ });
+ }
+
// 如果启用观影室，添加观影室入口
if (watchRoomContext?.isEnabled) {
items.push({
diff --git a/src/components/UserMenu.tsx b/src/components/UserMenu.tsx
index 802fc81..a31c53b 100644
--- a/src/components/UserMenu.tsx
+++ b/src/components/UserMenu.tsx
@@ -86,6 +86,7 @@ export const UserMenu: React.FC = () => {
const [enableOptimization, setEnableOptimization] = useState(true);
const [fluidSearch, setFluidSearch] = useState(true);
const [liveDirectConnect, setLiveDirectConnect] = useState(false);
+ const [danmakuHeatmapDisabled, setDanmakuHeatmapDisabled] = useState(false);
const [doubanDataSource, setDoubanDataSource] = useState('cmliussss-cdn-tencent');
const [doubanImageProxyType, setDoubanImageProxyType] = useState('cmliussss-cdn-tencent');
const [doubanImageProxyUrl, setDoubanImageProxyUrl] = useState('');
@@ -300,6 +301,11 @@ export const UserMenu: React.FC = () => {
if (savedLiveDirectConnect !== null) {
setLiveDirectConnect(JSON.parse(savedLiveDirectConnect));
}
+
+ const savedDanmakuHeatmapDisabled = localStorage.getItem('danmaku_heatmap_disabled');
+ if (savedDanmakuHeatmapDisabled !== null) {
+ setDanmakuHeatmapDisabled(savedDanmakuHeatmapDisabled === 'true');
+ }
}
}, []);
@@ -497,6 +503,13 @@ export const UserMenu: React.FC = () => {
}
};
+ const handleDanmakuHeatmapDisabledToggle = (value: boolean) => {
+ setDanmakuHeatmapDisabled(value);
+ if (typeof window !== 'undefined') {
+ localStorage.setItem('danmaku_heatmap_disabled', String(value));
+ }
+ };
+
const handleDoubanDataSourceChange = (value: string) => {
setDoubanDataSource(value);
if (typeof window !== 'undefined') {
@@ -553,6 +566,7 @@ export const UserMenu: React.FC = () => {
setEnableOptimization(true);
setFluidSearch(defaultFluidSearch);
setLiveDirectConnect(false);
+ setDanmakuHeatmapDisabled(false);
setDoubanProxyUrl(defaultDoubanProxy);
setDoubanDataSource(defaultDoubanProxyType);
setDoubanImageProxyType(defaultDoubanImageProxyType);
@@ -563,6 +577,7 @@ export const UserMenu: React.FC = () => {
localStorage.setItem('enableOptimization', JSON.stringify(true));
localStorage.setItem('fluidSearch', JSON.stringify(defaultFluidSearch));
localStorage.setItem('liveDirectConnect', JSON.stringify(false));
+ localStorage.setItem('danmaku_heatmap_disabled', 'false');
localStorage.setItem('doubanProxyUrl', defaultDoubanProxy);
localStorage.setItem('doubanDataSource', defaultDoubanProxyType);
localStorage.setItem('doubanImageProxyType', defaultDoubanImageProxyType);
@@ -1150,6 +1165,30 @@ export const UserMenu: React.FC = () => {
+ 找到 {results.total} 个资源
+
+
+ {/* 网盘类型过滤器 */}
+
+
+ {typeStats.map(({ type, count }) => {
+ const typeName = CLOUD_TYPE_NAMES[type] || type;
+ const typeColor = CLOUD_TYPE_COLORS[type] || CLOUD_TYPE_COLORS.others;
+
+ return (
+
+ );
+ })}
+
+
+ {/* 按网盘类型分类显示 */}
+ {filteredCloudTypes.map((cloudType) => {
+ const links = results.merged_by_type?.[cloudType];
+ if (!links || links.length === 0) return null;
+
+ const typeName = CLOUD_TYPE_NAMES[cloudType] || cloudType;
+ const typeColor = CLOUD_TYPE_COLORS[cloudType] || CLOUD_TYPE_COLORS.others;
+
+ return (
+
+ {/* 网盘类型标题 */}
+
+ );
+ })}
+
+
+ {typeName}
+
+
+ {links.length} 个链接
+
+
+
+ {/* 链接列表 */}
+
+ {links.map((link: PansouLink, index: number) => (
+
+
+ {/* 资源标题 */}
+ {link.note && (
+
+ ))}
+
+ {link.note}
+
+ )}
+
+ {/* 链接和密码 */}
+
+
+
+ {/* 来源和时间 */}
+
+
+
+ {/* 操作按钮 */}
+
+ {link.url}
+
+ {link.password && (
+
+ 提取码: {link.password}
+
+ )}
+
+
+
+
+
+ {link.source && (
+ 来源: {link.source}
+ )}
+ {link.datetime && (
+ {new Date(link.datetime).toLocaleDateString()}
+ )}
+
+
+ {/* 图片预览 */}
+ {link.images && link.images.length > 0 && (
+
+ {link.images.map((img, imgIndex) => (
+ 
+ ))}
+
+ )}
+
+
+
{/* 分割线 */}
diff --git a/src/components/VideoCard.tsx b/src/components/VideoCard.tsx
index 8160f6b..a7cbb76 100644
--- a/src/components/VideoCard.tsx
+++ b/src/components/VideoCard.tsx
@@ -659,7 +659,7 @@ const VideoCard = forwardRef
+
+
+ + 禁用弹幕热力图 +
++ 完全关闭弹幕热力图功能以提升性能（需手动刷新页面生效） +
+ | null = null;
// 从配置文件补充管理员配置
@@ -223,6 +224,7 @@ async function getInitConfig(configFile: string, subConfig: {
DanmakuApiToken: process.env.DANMAKU_API_TOKEN || '87654321',
// TMDB配置
TMDBApiKey: '',
+ TMDBProxy: '',
// 评论功能开关
EnableComments: false,
},
@@ -302,32 +304,69 @@ export async function getConfig(): Promise {
return cachedConfig;
}
- // 读 db
- let adminConfig: AdminConfig | null = null;
- let dbReadFailed = false;
- try {
- adminConfig = await db.getAdminConfig();
- } catch (e) {
- console.error('获取管理员配置失败:', e);
- dbReadFailed = true;
+ // 如果正在初始化，等待初始化完成
+ if (configInitPromise) {
+ return configInitPromise;
}
- // db 中无配置，执行一次初始化
- if (!adminConfig) {
- if (dbReadFailed) {
- // 数据库读取失败，使用默认配置但不保存，避免覆盖数据库
- console.warn('数据库读取失败，使用临时默认配置（不会保存到数据库）');
- adminConfig = await getInitConfig("");
- } else {
- // 数据库中确实没有配置，首次初始化并保存
- console.log('首次初始化配置');
- adminConfig = await getInitConfig("");
- await db.saveAdminConfig(adminConfig);
+ // 创建初始化 Promise
+ configInitPromise = (async () => {
+ // 读 db
+ let adminConfig: AdminConfig | null = null;
+ let dbReadFailed = false;
+ try {
+ adminConfig = await db.getAdminConfig();
+ } catch (e) {
+ console.error('获取管理员配置失败:', e);
+ dbReadFailed = true;
}
- }
- adminConfig = configSelfCheck(adminConfig);
- cachedConfig = adminConfig;
- return cachedConfig;
+
+ // db 中无配置，执行一次初始化
+ if (!adminConfig) {
+ if (dbReadFailed) {
+ // 数据库读取失败，使用默认配置但不保存，避免覆盖数据库
+ console.warn('数据库读取失败，使用临时默认配置（不会保存到数据库）');
+ adminConfig = await getInitConfig("");
+ } else {
+ // 数据库中确实没有配置，首次初始化并保存
+ console.log('首次初始化配置');
+ adminConfig = await getInitConfig("");
+ await db.saveAdminConfig(adminConfig);
+ }
+ }
+ adminConfig = configSelfCheck(adminConfig);
+ cachedConfig = adminConfig;
+
+ // 自动迁移用户（如果配置中有用户且V2存储支持）
+ // 过滤掉站长后检查是否有需要迁移的用户
+ const nonOwnerUsers = adminConfig.UserConfig.Users.filter(
+ (u) => u.username !== process.env.USERNAME
+ );
+ if (!dbReadFailed && nonOwnerUsers.length > 0) {
+ try {
+ // 检查是否支持V2存储
+ const storage = (db as any).storage;
+ if (storage && typeof storage.createUserV2 === 'function') {
+ console.log('检测到配置中有用户，开始自动迁移...');
+ await db.migrateUsersFromConfig(adminConfig);
+ // 迁移完成后，清空配置中的用户列表并保存
+ adminConfig.UserConfig.Users = [];
+ await db.saveAdminConfig(adminConfig);
+ cachedConfig = adminConfig;
+ console.log('用户自动迁移完成');
+ }
+ } catch (error) {
+ console.error('自动迁移用户失败:', error);
+ // 不影响主流程，继续执行
+ }
+ }
+
+ // 清除初始化 Promise
+ configInitPromise = null;
+ return cachedConfig;
+ })();
+
+ return configInitPromise;
}
export function configSelfCheck(adminConfig: AdminConfig): AdminConfig {
@@ -469,14 +508,15 @@ export async function getAvailableApiSites(user?: string): Promise {
return allApiSites;
}
- const userConfig = config.UserConfig.Users.find((u) => u.username === user);
- if (!userConfig) {
+ // 从V2存储中获取用户信息
+ const userInfoV2 = await db.getUserInfoV2(user);
+ if (!userInfoV2) {
return allApiSites;
}
// 优先根据用户自己的 enabledApis 配置查找
- if (userConfig.enabledApis && userConfig.enabledApis.length > 0) {
- const userApiSitesSet = new Set(userConfig.enabledApis);
+ if (userInfoV2.enabledApis && userInfoV2.enabledApis.length > 0) {
+ const userApiSitesSet = new Set(userInfoV2.enabledApis);
return allApiSites.filter((s) => userApiSitesSet.has(s.key)).map((s) => ({
key: s.key,
name: s.name,
@@ -486,11 +526,11 @@ export async function getAvailableApiSites(user?: string): Promise {
}
// 如果没有 enabledApis 配置，则根据 tags 查找
- if (userConfig.tags && userConfig.tags.length > 0 && config.UserConfig.Tags) {
+ if (userInfoV2.tags && userInfoV2.tags.length > 0 && config.UserConfig.Tags) {
const enabledApisFromTags = new Set();
// 遍历用户的所有 tags，收集对应的 enabledApis
- userConfig.tags.forEach(tagName => {
+ userInfoV2.tags.forEach(tagName => {
const tagConfig = config.UserConfig.Tags?.find(t => t.name === tagName);
if (tagConfig && tagConfig.enabledApis) {
tagConfig.enabledApis.forEach(apiKey => enabledApisFromTags.add(apiKey));
diff --git a/src/lib/db.ts b/src/lib/db.ts
index 074c4cc..7bcfb2b 100644
--- a/src/lib/db.ts
+++ b/src/lib/db.ts
@@ -132,7 +132,7 @@ export class DbManager {
return favorite !== null;
}
- // ---------- 用户相关 ----------
+ // ---------- 用户相关（旧版本，保持兼容） ----------
async registerUser(userName: string, password: string): Promise {
await this.storage.registerUser(userName, password);
}
@@ -154,6 +154,199 @@ export class DbManager {
await this.storage.deleteUser(userName);
}
+ // ---------- 用户相关（新版本） ----------
+ async createUserV2(
+ userName: string,
+ password: string,
+ role: 'owner' | 'admin' | 'user' = 'user',
+ tags?: string[],
+ oidcSub?: string,
+ enabledApis?: string[]
+ ): Promise {
+ if (typeof (this.storage as any).createUserV2 === 'function') {
+ await (this.storage as any).createUserV2(userName, password, role, tags, oidcSub, enabledApis);
+ }
+ }
+
+ async verifyUserV2(userName: string, password: string): Promise {
+ if (typeof (this.storage as any).verifyUserV2 === 'function') {
+ return (this.storage as any).verifyUserV2(userName, password);
+ }
+ return false;
+ }
+
+ async getUserInfoV2(userName: string): Promise<{
+ role: 'owner' | 'admin' | 'user';
+ banned: boolean;
+ tags?: string[];
+ oidcSub?: string;
+ enabledApis?: string[];
+ created_at: number;
+ } | null> {
+ if (typeof (this.storage as any).getUserInfoV2 === 'function') {
+ return (this.storage as any).getUserInfoV2(userName);
+ }
+ return null;
+ }
+
+ async updateUserInfoV2(
+ userName: string,
+ updates: {
+ role?: 'owner' | 'admin' | 'user';
+ banned?: boolean;
+ tags?: string[];
+ oidcSub?: string;
+ enabledApis?: string[];
+ }
+ ): Promise {
+ if (typeof (this.storage as any).updateUserInfoV2 === 'function') {
+ await (this.storage as any).updateUserInfoV2(userName, updates);
+ }
+ }
+
+ async changePasswordV2(userName: string, newPassword: string): Promise {
+ if (typeof (this.storage as any).changePasswordV2 === 'function') {
+ await (this.storage as any).changePasswordV2(userName, newPassword);
+ }
+ }
+
+ async checkUserExistV2(userName: string): Promise {
+ if (typeof (this.storage as any).checkUserExistV2 === 'function') {
+ return (this.storage as any).checkUserExistV2(userName);
+ }
+ return false;
+ }
+
+ async getUserByOidcSub(oidcSub: string): Promise {
+ if (typeof (this.storage as any).getUserByOidcSub === 'function') {
+ return (this.storage as any).getUserByOidcSub(oidcSub);
+ }
+ return null;
+ }
+
+ async getUserListV2(
+ offset: number = 0,
+ limit: number = 20,
+ ownerUsername?: string
+ ): Promise<{
+ users: Array<{
+ username: string;
+ role: 'owner' | 'admin' | 'user';
+ banned: boolean;
+ tags?: string[];
+ oidcSub?: string;
+ enabledApis?: string[];
+ created_at: number;
+ }>;
+ total: number;
+ }> {
+ if (typeof (this.storage as any).getUserListV2 === 'function') {
+ return (this.storage as any).getUserListV2(offset, limit, ownerUsername);
+ }
+ return { users: [], total: 0 };
+ }
+
+ async deleteUserV2(userName: string): Promise {
+ if (typeof (this.storage as any).deleteUserV2 === 'function') {
+ await (this.storage as any).deleteUserV2(userName);
+ }
+ }
+
+ async getUsersByTag(tagName: string): Promise {
+ if (typeof (this.storage as any).getUsersByTag === 'function') {
+ return (this.storage as any).getUsersByTag(tagName);
+ }
+ return [];
+ }
+
+ // ---------- 数据迁移 ----------
+ async migrateUsersFromConfig(adminConfig: AdminConfig): Promise {
+ if (typeof (this.storage as any).createUserV2 !== 'function') {
+ throw new Error('当前存储类型不支持新版用户存储');
+ }
+
+ const users = adminConfig.UserConfig.Users;
+ if (!users || users.length === 0) {
+ return;
+ }
+
+ console.log(`开始迁移 ${users.length} 个用户...`);
+
+ for (const user of users) {
+ try {
+ // 跳过环境变量中的站长（站长使用环境变量认证，不需要迁移）
+ if (user.username === process.env.USERNAME) {
+ console.log(`跳过站长 ${user.username} 的迁移`);
+ continue;
+ }
+
+ // 检查用户是否已经迁移
+ const exists = await this.checkUserExistV2(user.username);
+ if (exists) {
+ console.log(`用户 ${user.username} 已存在，跳过迁移`);
+ continue;
+ }
+
+ // 获取密码
+ let password = '';
+
+ // 如果是OIDC用户，生成随机密码（OIDC用户不需要密码登录）
+ if ((user as any).oidcSub) {
+ password = crypto.randomUUID();
+ console.log(`用户 ${user.username} (OIDC用户) 使用随机密码迁移`);
+ }
+ // 尝试从旧的存储中获取密码
+ else {
+ try {
+ if ((this.storage as any).client) {
+ const storedPassword = await (this.storage as any).client.get(`u:${user.username}:pwd`);
+ if (storedPassword) {
+ password = storedPassword;
+ console.log(`用户 ${user.username} 使用旧密码迁移`);
+ } else {
+ // 没有旧密码，使用默认密码
+ password = 'defaultPassword123';
+ console.log(`用户 ${user.username} 没有旧密码，使用默认密码`);
+ }
+ } else {
+ password = 'defaultPassword123';
+ }
+ } catch (err) {
+ console.error(`获取用户 ${user.username} 的密码失败，使用默认密码`, err);
+ password = 'defaultPassword123';
+ }
+ }
+
+ // 将站长角色转换为普通角色
+ const migratedRole = user.role === 'owner' ? 'user' : user.role;
+ if (user.role === 'owner') {
+ console.log(`用户 ${user.username} 的角色从 owner 转换为 user`);
+ }
+
+ // 创建新用户
+ await this.createUserV2(
+ user.username,
+ password,
+ migratedRole,
+ user.tags,
+ (user as any).oidcSub,
+ user.enabledApis
+ );
+
+ // 如果用户被封禁，更新状态
+ if (user.banned) {
+ await this.updateUserInfoV2(user.username, { banned: true });
+ }
+
+ console.log(`用户 ${user.username} 迁移成功`);
+ } catch (err) {
+ console.error(`迁移用户 ${user.username} 失败:`, err);
+ }
+ }
+
+ console.log('用户迁移完成');
+ }
+
// ---------- 搜索历史 ----------
async getSearchHistory(userName: string): Promise {
return this.storage.getSearchHistory(userName);
diff --git a/src/lib/lock.ts b/src/lib/lock.ts
new file mode 100644
index 0000000..e98f794
--- /dev/null
+++ b/src/lib/lock.ts
@@ -0,0 +1,96 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+// 简单的内存锁管理器
+class LockManager {
+ private locks: Map void> }> = new Map();
+ private readonly LOCK_TIMEOUT = 10000; // 10秒超时
+
+ async acquire(key: string): Promise<() => void> {
+ // 获取或创建锁对象
+ if (!this.locks.has(key)) {
+ this.locks.set(key, { locked: false, queue: [] });
+ }
+
+ const lock = this.locks.get(key)!;
+
+ // 如果锁未被占用，立即获取
+ if (!lock.locked) {
+ lock.locked = true;
+
+ // 设置超时自动释放
+ const timeoutId = setTimeout(() => {
+ this.release(key);
+ }, this.LOCK_TIMEOUT);
+
+ // 返回释放函数
+ return () => {
+ clearTimeout(timeoutId);
+ this.release(key);
+ };
+ }
+
+ // 如果锁已被占用，等待
+ return new Promise((resolve, reject) => {
+ const timeoutId = setTimeout(() => {
+ // 超时，从队列中移除
+ const index = lock.queue.indexOf(callback);
+ if (index > -1) {
+ lock.queue.splice(index, 1);
+ }
+ reject(new Error('获取锁超时'));
+ }, this.LOCK_TIMEOUT);
+
+ const callback = () => {
+ clearTimeout(timeoutId);
+ lock.locked = true;
+
+ // 设置超时自动释放
+ const lockTimeoutId = setTimeout(() => {
+ this.release(key);
+ }, this.LOCK_TIMEOUT);
+
+ resolve(() => {
+ clearTimeout(lockTimeoutId);
+ this.release(key);
+ });
+ };
+
+ lock.queue.push(callback);
+ });
+ }
+
+ private release(key: string): void {
+ const lock = this.locks.get(key);
+ if (!lock) return;
+
+ // 如果队列中有等待者，唤醒下一个
+ if (lock.queue.length > 0) {
+ const next = lock.queue.shift();
+ if (next) {
+ next();
+ }
+ } else {
+ // 没有等待者，释放锁
+ lock.locked = false;
+ // 清理空的锁对象
+ this.locks.delete(key);
+ }
+ }
+
+ // 清理所有锁（用于测试或重置）
+ clear(): void {
+ this.locks.clear();
+ }
+}
+
+// 全局单例
+const globalKey = Symbol.for('__MOONTV_LOCK_MANAGER__');
+let _lockManager: LockManager | undefined = (global as any)[globalKey];
+
+if (!_lockManager) {
+ _lockManager = new LockManager();
+ (global as any)[globalKey] = _lockManager;
+}
+
+// TypeScript doesn't recognize that lockManager is always defined after the if block
+export const lockManager = _lockManager as LockManager;
diff --git a/src/lib/openlist-cache.ts b/src/lib/openlist-cache.ts
new file mode 100644
index 0000000..0f01899
--- /dev/null
+++ b/src/lib/openlist-cache.ts
@@ -0,0 +1,97 @@
+// metainfo.json 缓存 (7天)
+interface MetaInfoCacheEntry {
+ expiresAt: number;
+ data: MetaInfo;
+}
+
+// videoinfo.json 缓存 (1天)
+interface VideoInfoCacheEntry {
+ expiresAt: number;
+ data: VideoInfo;
+}
+
+const METAINFO_CACHE_TTL_MS = 7 * 24 * 60 * 60 * 1000; // 7天
+const VIDEOINFO_CACHE_TTL_MS = (parseInt(process.env.VIDEOINFO_CACHE_MINUTES || '1440', 10)) * 60 * 1000; // 默认1天
+
+const METAINFO_CACHE: Map = new Map();
+const VIDEOINFO_CACHE: Map = new Map();
+
+export interface MetaInfo {
+ folders: {
+ [folderName: string]: {
+ tmdb_id: number;
+ title: string;
+ poster_path: string | null;
+ release_date: string;
+ overview: string;
+ vote_average: number;
+ media_type: 'movie' | 'tv';
+ last_updated: number;
+ failed?: boolean; // 标记是否搜索失败
+ };
+ };
+ last_refresh: number;
+}
+
+export interface VideoInfo {
+ episodes: {
+ [fileName: string]: {
+ episode: number;
+ season?: number;
+ title?: string;
+ parsed_from: 'videoinfo' | 'filename';
+ };
+ };
+ last_updated: number;
+}
+
+// MetaInfo 缓存操作
+export function getCachedMetaInfo(rootPath: string): MetaInfo | null {
+ const entry = METAINFO_CACHE.get(rootPath);
+ if (!entry) return null;
+
+ if (entry.expiresAt <= Date.now()) {
+ METAINFO_CACHE.delete(rootPath);
+ return null;
+ }
+
+ return entry.data;
+}
+
+export function setCachedMetaInfo(rootPath: string, data: MetaInfo): void {
+ METAINFO_CACHE.set(rootPath, {
+ expiresAt: Date.now() + METAINFO_CACHE_TTL_MS,
+ data,
+ });
+}
+
+export function invalidateMetaInfoCache(rootPath: string): void {
+ METAINFO_CACHE.delete(rootPath);
+}
+
+// VideoInfo 缓存操作
+export function getCachedVideoInfo(folderPath: string): VideoInfo | null {
+ const entry = VIDEOINFO_CACHE.get(folderPath);
+ if (!entry) return null;
+
+ if (entry.expiresAt <= Date.now()) {
+ VIDEOINFO_CACHE.delete(folderPath);
+ return null;
+ }
+
+ return entry.data;
+}
+
+export function setCachedVideoInfo(
+ folderPath: string,
+ data: VideoInfo
+): void {
+ VIDEOINFO_CACHE.set(folderPath, {
+ expiresAt: Date.now() + VIDEOINFO_CACHE_TTL_MS,
+ data,
+ });
+}
+
+export function invalidateVideoInfoCache(folderPath: string): void {
+ VIDEOINFO_CACHE.delete(folderPath);
+}
diff --git a/src/lib/openlist.client.ts b/src/lib/openlist.client.ts
new file mode 100644
index 0000000..7d4bdcc
--- /dev/null
+++ b/src/lib/openlist.client.ts
@@ -0,0 +1,318 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+// Token 内存缓存
+const tokenCache = new Map();
+
+export interface OpenListFile {
+ name: string;
+ size: number;
+ is_dir: boolean;
+ modified: string;
+ sign?: string; // 临时下载签名
+ raw_url?: string; // 完整下载链接
+ thumb?: string;
+ type: number;
+ path?: string;
+}
+
+export interface OpenListListResponse {
+ code: number;
+ message: string;
+ data: {
+ content: OpenListFile[];
+ total: number;
+ readme: string;
+ write: boolean;
+ };
+}
+
+export interface OpenListGetResponse {
+ code: number;
+ message: string;
+ data: OpenListFile;
+}
+
+export class OpenListClient {
+ private token: string = '';
+
+ constructor(
+ private baseURL: string,
+ private username: string,
+ private password: string
+ ) {}
+
+ /**
+ * 使用账号密码登录获取Token
+ */
+ static async login(
+ baseURL: string,
+ username: string,
+ password: string
+ ): Promise {
+ const response = await fetch(`${baseURL}/api/auth/login`, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ },
+ body: JSON.stringify({
+ username,
+ password,
+ }),
+ });
+
+ if (!response.ok) {
+ throw new Error(`OpenList 登录失败: ${response.status}`);
+ }
+
+ const data = await response.json();
+ if (data.code !== 200 || !data.data?.token) {
+ throw new Error('OpenList 登录失败: 未获取到Token');
+ }
+
+ return data.data.token;
+ }
+
+ /**
+ * 获取缓存的 Token 或重新登录
+ */
+ private async getToken(): Promise {
+ const cacheKey = `${this.baseURL}:${this.username}`;
+ const cached = tokenCache.get(cacheKey);
+
+ // 如果有缓存且未过期，直接返回
+ if (cached && cached.expiresAt > Date.now()) {
+ this.token = cached.token;
+ return this.token;
+ }
+
+ // 否则重新登录
+ console.log('[OpenListClient] Token 不存在或已过期，重新登录');
+ this.token = await OpenListClient.login(
+ this.baseURL,
+ this.username,
+ this.password
+ );
+
+ // 缓存 Token，设置 1 小时过期
+ tokenCache.set(cacheKey, {
+ token: this.token,
+ expiresAt: Date.now() + 60 * 60 * 1000,
+ });
+
+ console.log('[OpenListClient] 登录成功，Token 已缓存');
+ return this.token;
+ }
+
+ /**
+ * 清除 Token 缓存（当 Token 失效时调用）
+ */
+ private clearTokenCache(): void {
+ const cacheKey = `${this.baseURL}:${this.username}`;
+ tokenCache.delete(cacheKey);
+ console.log('[OpenListClient] Token 缓存已清除');
+ }
+
+ /**
+ * 执行请求，如果401则清除缓存并重新登录后重试
+ */
+ private async fetchWithRetry(
+ url: string,
+ options: RequestInit,
+ retried = false
+ ): Promise {
+ // 获取 Token
+ const token = await this.getToken();
+
+ // 更新请求头中的 Token
+ const requestOptions = {
+ ...options,
+ headers: {
+ ...options.headers,
+ Authorization: token,
+ },
+ };
+
+ const response = await fetch(url, requestOptions);
+
+ // 检查 HTTP status 401
+ if (response.status === 401 && !retried) {
+ console.log('[OpenListClient] 收到 HTTP 401，清除 Token 缓存并重试');
+ this.clearTokenCache();
+ return this.fetchWithRetry(url, options, true);
+ }
+
+ // 检查响应体中的 code 字段（OpenList 的 Token 过期时 HTTP status 是 200，但 code 是 401）
+ if (response.ok && !retried) {
+ try {
+ // 克隆响应以便读取 JSON
+ const clonedResponse = response.clone();
+ const data = await clonedResponse.json();
+
+ if (data.code === 401) {
+ console.log('[OpenListClient] 响应体 code 为 401，Token 已过期，清除缓存并重试');
+ this.clearTokenCache();
+ return this.fetchWithRetry(url, options, true);
+ }
+ } catch (error) {
+ // 如果解析 JSON 失败，忽略错误，返回原始响应
+ console.warn('[OpenListClient] 解析响应 JSON 失败:', error);
+ }
+ }
+
+ return response;
+ }
+
+ private async getHeaders() {
+ const token = await this.getToken();
+ return {
+ Authorization: token, // 不带 bearer
+ 'Content-Type': 'application/json',
+ };
+ }
+
+ // 列出目录
+ async listDirectory(
+ path: string,
+ page = 1,
+ perPage = 100,
+ refresh = false
+ ): Promise {
+ const response = await this.fetchWithRetry(`${this.baseURL}/api/fs/list`, {
+ method: 'POST',
+ headers: await this.getHeaders(),
+ body: JSON.stringify({
+ path,
+ password: '',
+ refresh,
+ page,
+ per_page: perPage,
+ }),
+ });
+
+ if (!response.ok) {
+ throw new Error(`OpenList API 错误: ${response.status}`);
+ }
+
+ return response.json();
+ }
+
+ // 获取文件信息
+ async getFile(path: string): Promise {
+ const response = await this.fetchWithRetry(`${this.baseURL}/api/fs/get`, {
+ method: 'POST',
+ headers: await this.getHeaders(),
+ body: JSON.stringify({
+ path,
+ password: '',
+ }),
+ });
+
+ if (!response.ok) {
+ throw new Error(`OpenList API 错误: ${response.status}`);
+ }
+
+ return response.json();
+ }
+
+ // 上传文件
+ async uploadFile(path: string, content: string): Promise {
+ const token = await this.getToken();
+ const response = await this.fetchWithRetry(`${this.baseURL}/api/fs/put`, {
+ method: 'PUT',
+ headers: {
+ Authorization: token,
+ 'Content-Type': 'text/plain; charset=utf-8',
+ 'File-Path': encodeURIComponent(path),
+ 'As-Task': 'false',
+ },
+ body: content,
+ });
+
+ if (!response.ok) {
+ const errorText = await response.text();
+ throw new Error(`OpenList 上传失败: ${response.status} - ${errorText}`);
+ }
+
+ // 上传成功后刷新目录缓存
+ const dir = path.substring(0, path.lastIndexOf('/')) || '/';
+ await this.refreshDirectory(dir);
+ }
+
+ // 刷新目录缓存
+ async refreshDirectory(path: string): Promise {
+ try {
+ const response = await this.fetchWithRetry(`${this.baseURL}/api/fs/list`, {
+ method: 'POST',
+ headers: await this.getHeaders(),
+ body: JSON.stringify({
+ path,
+ password: '',
+ refresh: true,
+ page: 1,
+ per_page: 1,
+ }),
+ });
+
+ if (!response.ok) {
+ console.warn(`刷新目录缓存失败: ${response.status}`);
+ }
+ } catch (error) {
+ console.warn('刷新目录缓存失败:', error);
+ }
+ }
+
+ // 删除文件
+ async deleteFile(path: string): Promise {
+ const dir = path.substring(0, path.lastIndexOf('/')) || '/';
+ const fileName = path.substring(path.lastIndexOf('/') + 1);
+
+ const response = await this.fetchWithRetry(`${this.baseURL}/api/fs/remove`, {
+ method: 'POST',
+ headers: await this.getHeaders(),
+ body: JSON.stringify({
+ names: [fileName],
+ dir: dir,
+ }),
+ });
+
+ if (!response.ok) {
+ throw new Error(`OpenList 删除失败: ${response.status}`);
+ }
+ }
+
+ // 检查连通性
+ async checkConnectivity(): Promise<{ success: boolean; message: string }> {
+ try {
+ const response = await this.fetchWithRetry(`${this.baseURL}/api/me`, {
+ method: 'GET',
+ headers: await this.getHeaders(),
+ });
+
+ if (response.status !== 200) {
+ return {
+ success: false,
+ message: `HTTP 状态码错误: ${response.status}`,
+ };
+ }
+
+ const data = await response.json();
+
+ if (data.code !== 200) {
+ return {
+ success: false,
+ message: `响应码错误: ${data.code}`,
+ };
+ }
+
+ return {
+ success: true,
+ message: '连接成功',
+ };
+ } catch (error) {
+ return {
+ success: false,
+ message: error instanceof Error ? error.message : '连接失败',
+ };
+ }
+ }
+}
diff --git a/src/lib/pansou.client.ts b/src/lib/pansou.client.ts
new file mode 100644
index 0000000..b928d3d
--- /dev/null
+++ b/src/lib/pansou.client.ts
@@ -0,0 +1,218 @@
+/* eslint-disable @typescript-eslint/no-explicit-any,no-console */
+
+/**
+ * Pansou 网盘搜索 API 客户端
+ * 文档: https://github.com/fish2018/pansou
+ */
+
+// Token 缓存
+let cachedToken: string | null = null;
+let tokenExpiry: number | null = null;
+
+export interface PansouLink {
+ url: string;
+ password: string;
+ note: string;
+ datetime: string;
+ source: string;
+ images?: string[];
+}
+
+export interface PansouSearchResult {
+ total: number;
+ merged_by_type?: {
+ [key: string]: PansouLink[];
+ };
+}
+
+export interface PansouLoginResponse {
+ token: string;
+ expires_at: number;
+ username: string;
+}
+
+/**
+ * 登录 Pansou 获取 Token
+ */
+export async function loginPansou(
+ apiUrl: string,
+ username: string,
+ password: string
+): Promise {
+ try {
+ const response = await fetch(`${apiUrl}/api/auth/login`, {
+ method: 'POST',
+ headers: {
+ 'Content-Type': 'application/json',
+ },
+ body: JSON.stringify({ username, password }),
+ });
+
+ if (!response.ok) {
+ const error = await response.json();
+ throw new Error(error.error || '登录失败');
+ }
+
+ const data: PansouLoginResponse = await response.json();
+
+ // 缓存 Token
+ cachedToken = data.token;
+ tokenExpiry = data.expires_at;
+
+ return data.token;
+ } catch (error) {
+ console.error('Pansou 登录失败:', error);
+ throw error;
+ }
+}
+
+/**
+ * 获取有效的 Token（自动处理登录和缓存）
+ */
+async function getValidToken(
+ apiUrl: string,
+ username?: string,
+ password?: string
+): Promise {
+ // 如果没有配置账号密码，返回 null（不需要认证）
+ if (!username || !password) {
+ return null;
+ }
+
+ // 检查缓存的 Token 是否有效
+ if (cachedToken && tokenExpiry) {
+ const now = Math.floor(Date.now() / 1000);
+ // 提前 5 分钟刷新 Token
+ if (tokenExpiry - now > 300) {
+ return cachedToken;
+ }
+ }
+
+ // Token 过期或不存在，重新登录
+ try {
+ return await loginPansou(apiUrl, username, password);
+ } catch (error) {
+ console.error('获取 Pansou Token 失败:', error);
+ return null;
+ }
+}
+
+/**
+ * 搜索网盘资源
+ */
+export async function searchPansou(
+ apiUrl: string,
+ keyword: string,
+ options?: {
+ username?: string;
+ password?: string;
+ refresh?: boolean;
+ cloudTypes?: string[];
+ }
+): Promise {
+ try {
+ // 获取 Token（如果需要认证）
+ const token = await getValidToken(
+ apiUrl,
+ options?.username,
+ options?.password
+ );
+
+ // 构建请求头
+ const headers: Record = {
+ 'Content-Type': 'application/json',
+ };
+
+ if (token) {
+ headers['Authorization'] = `Bearer ${token}`;
+ }
+
+ // 构建请求体
+ const body: any = {
+ kw: keyword,
+ res: 'merge', // 只返回按网盘类型分类的结果
+ };
+
+ if (options?.refresh) {
+ body.refresh = true;
+ }
+
+ if (options?.cloudTypes && options.cloudTypes.length > 0) {
+ body.cloud_types = options.cloudTypes;
+ }
+
+ const response = await fetch(`${apiUrl}/api/search`, {
+ method: 'POST',
+ headers,
+ body: JSON.stringify(body),
+ });
+
+ if (!response.ok) {
+ const error = await response.json();
+ throw new Error(error.error || error.message || '搜索失败');
+ }
+
+ const responseData = await response.json();
+
+ // Pansou API 返回的数据结构是 { code, message, data }
+ // 实际数据在 data 字段中
+ let data: PansouSearchResult;
+
+ if (responseData.data) {
+ // 如果有 data 字段，使用 data 中的内容
+ data = responseData.data;
+ } else {
+ // 否则直接使用返回的数据
+ data = responseData;
+ }
+
+ // 验证返回的数据结构
+ if (!data || typeof data !== 'object') {
+ throw new Error('返回数据格式错误');
+ }
+
+ // 确保 merged_by_type 存在
+ if (!data.merged_by_type) {
+ data.merged_by_type = {};
+ }
+
+ // 确保 total 存在
+ if (typeof data.total !== 'number') {
+ data.total = 0;
+ }
+
+ return data;
+ } catch (error) {
+ console.error('Pansou 搜索失败:', error);
+ throw error;
+ }
+}
+
+/**
+ * 清除缓存的 Token
+ */
+export function clearPansouToken(): void {
+ cachedToken = null;
+ tokenExpiry = null;
+}
+
+/**
+ * 检查 Pansou 服务是否可用
+ */
+export async function checkPansouHealth(apiUrl: string): Promise {
+ try {
+ const response = await fetch(`${apiUrl}/api/health`, {
+ method: 'GET',
+ });
+
+ if (!response.ok) {
+ return false;
+ }
+
+ const data = await response.json();
+ return data.status === 'ok';
+ } catch (error) {
+ console.error('Pansou 健康检查失败:', error);
+ return false;
+ }
+}
diff --git a/src/lib/redis-base.db.ts b/src/lib/redis-base.db.ts
index 98ba2a0..fe98a43 100644
--- a/src/lib/redis-base.db.ts
+++ b/src/lib/redis-base.db.ts
@@ -242,7 +242,7 @@ export abstract class BaseRedisStorage implements IStorage {
await this.withRetry(() => this.client.del(this.favKey(userName, key)));
}
- // ---------- 用户注册 / 登录 ----------
+ // ---------- 用户注册 / 登录（旧版本，保持兼容） ----------
private userPwdKey(user: string) {
return `u:${user}:pwd`;
}
@@ -314,6 +314,322 @@ export abstract class BaseRedisStorage implements IStorage {
}
}
+ // ---------- 新版用户存储（使用Hash和Sorted Set） ----------
+ private userInfoKey(userName: string) {
+ return `user:${userName}:info`;
+ }
+
+ private userListKey() {
+ return 'user:list';
+ }
+
+ private oidcSubKey(oidcSub: string) {
+ return `oidc:sub:${oidcSub}`;
+ }
+
+ // SHA256加密密码
+ private async hashPassword(password: string): Promise {
+ const encoder = new TextEncoder();
+ const data = encoder.encode(password);
+ const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+ const hashArray = Array.from(new Uint8Array(hashBuffer));
+ return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+ }
+
+ // 创建新用户（新版本）
+ async createUserV2(
+ userName: string,
+ password: string,
+ role: 'owner' | 'admin' | 'user' = 'user',
+ tags?: string[],
+ oidcSub?: string,
+ enabledApis?: string[]
+ ): Promise {
+ const hashedPassword = await this.hashPassword(password);
+ const createdAt = Date.now();
+
+ // 存储用户信息到Hash
+ const userInfo: Record = {
+ role,
+ banned: 'false',
+ password: hashedPassword,
+ created_at: createdAt.toString(),
+ };
+
+ if (tags && tags.length > 0) {
+ userInfo.tags = JSON.stringify(tags);
+ }
+
+ if (enabledApis && enabledApis.length > 0) {
+ userInfo.enabledApis = JSON.stringify(enabledApis);
+ }
+
+ if (oidcSub) {
+ userInfo.oidcSub = oidcSub;
+ // 创建OIDC映射
+ await this.withRetry(() => this.client.set(this.oidcSubKey(oidcSub), userName));
+ }
+
+ await this.withRetry(() => this.client.hSet(this.userInfoKey(userName), userInfo));
+
+ // 添加到用户列表（Sorted Set，按注册时间排序）
+ await this.withRetry(() => this.client.zAdd(this.userListKey(), {
+ score: createdAt,
+ value: userName,
+ }));
+
+ // 如果创建的是站长用户，清除站长存在状态缓存
+ if (userName === process.env.USERNAME) {
+ const { ownerExistenceCache } = await import('./user-cache');
+ ownerExistenceCache.delete(userName);
+ }
+ }
+
+ // 验证用户密码（新版本）
+ async verifyUserV2(userName: string, password: string): Promise {
+ const userInfo = await this.withRetry(() =>
+ this.client.hGetAll(this.userInfoKey(userName))
+ );
+
+ if (!userInfo || !userInfo.password) {
+ return false;
+ }
+
+ const hashedPassword = await this.hashPassword(password);
+ return userInfo.password === hashedPassword;
+ }
+
+ // 获取用户信息（新版本）
+ async getUserInfoV2(userName: string): Promise<{
+ role: 'owner' | 'admin' | 'user';
+ banned: boolean;
+ tags?: string[];
+ oidcSub?: string;
+ enabledApis?: string[];
+ created_at: number;
+ } | null> {
+ const userInfo = await this.withRetry(() =>
+ this.client.hGetAll(this.userInfoKey(userName))
+ );
+
+ if (!userInfo || Object.keys(userInfo).length === 0) {
+ return null;
+ }
+
+ return {
+ role: (userInfo.role as 'owner' | 'admin' | 'user') || 'user',
+ banned: userInfo.banned === 'true',
+ tags: userInfo.tags ? JSON.parse(userInfo.tags) : undefined,
+ oidcSub: userInfo.oidcSub,
+ enabledApis: userInfo.enabledApis ? JSON.parse(userInfo.enabledApis) : undefined,
+ created_at: parseInt(userInfo.created_at || '0', 10),
+ };
+ }
+
+ // 更新用户信息（新版本）
+ async updateUserInfoV2(
+ userName: string,
+ updates: {
+ role?: 'owner' | 'admin' | 'user';
+ banned?: boolean;
+ tags?: string[];
+ oidcSub?: string;
+ enabledApis?: string[];
+ }
+ ): Promise {
+ const userInfo: Record = {};
+
+ if (updates.role !== undefined) {
+ userInfo.role = updates.role;
+ }
+
+ if (updates.banned !== undefined) {
+ userInfo.banned = updates.banned ? 'true' : 'false';
+ }
+
+ if (updates.tags !== undefined) {
+ if (updates.tags.length > 0) {
+ userInfo.tags = JSON.stringify(updates.tags);
+ } else {
+ // 删除tags字段
+ await this.withRetry(() => this.client.hDel(this.userInfoKey(userName), 'tags'));
+ }
+ }
+
+ if (updates.enabledApis !== undefined) {
+ if (updates.enabledApis.length > 0) {
+ userInfo.enabledApis = JSON.stringify(updates.enabledApis);
+ } else {
+ // 删除enabledApis字段
+ await this.withRetry(() => this.client.hDel(this.userInfoKey(userName), 'enabledApis'));
+ }
+ }
+
+ if (updates.oidcSub !== undefined) {
+ const oldInfo = await this.getUserInfoV2(userName);
+ if (oldInfo?.oidcSub && oldInfo.oidcSub !== updates.oidcSub) {
+ // 删除旧的OIDC映射
+ await this.withRetry(() => this.client.del(this.oidcSubKey(oldInfo.oidcSub!)));
+ }
+ userInfo.oidcSub = updates.oidcSub;
+ // 创建新的OIDC映射
+ await this.withRetry(() => this.client.set(this.oidcSubKey(updates.oidcSub!), userName));
+ }
+
+ if (Object.keys(userInfo).length > 0) {
+ await this.withRetry(() => this.client.hSet(this.userInfoKey(userName), userInfo));
+ }
+ }
+
+ // 修改用户密码（新版本）
+ async changePasswordV2(userName: string, newPassword: string): Promise {
+ const hashedPassword = await this.hashPassword(newPassword);
+ await this.withRetry(() =>
+ this.client.hSet(this.userInfoKey(userName), 'password', hashedPassword)
+ );
+ }
+
+ // 检查用户是否存在（新版本）
+ async checkUserExistV2(userName: string): Promise {
+ const exists = await this.withRetry(() =>
+ this.client.exists(this.userInfoKey(userName))
+ );
+ return exists === 1;
+ }
+
+ // 通过OIDC Sub查找用户名
+ async getUserByOidcSub(oidcSub: string): Promise {
+ const userName = await this.withRetry(() =>
+ this.client.get(this.oidcSubKey(oidcSub))
+ );
+ return userName ? ensureString(userName) : null;
+ }
+
+ // 获取用户列表（分页，新版本）
+ async getUserListV2(
+ offset: number = 0,
+ limit: number = 20,
+ ownerUsername?: string
+ ): Promise<{
+ users: Array<{
+ username: string;
+ role: 'owner' | 'admin' | 'user';
+ banned: boolean;
+ tags?: string[];
+ oidcSub?: string;
+ enabledApis?: string[];
+ created_at: number;
+ }>;
+ total: number;
+ }> {
+ // 获取总数
+ let total = await this.withRetry(() => this.client.zCard(this.userListKey()));
+
+ // 检查站长是否在数据库中（使用缓存）
+ let ownerInfo = null;
+ let ownerInDatabase = false;
+ if (ownerUsername) {
+ // 先检查缓存
+ const { ownerExistenceCache } = await import('./user-cache');
+ const cachedExists = ownerExistenceCache.get(ownerUsername);
+
+ if (cachedExists !== null) {
+ // 使用缓存的结果
+ ownerInDatabase = cachedExists;
+ if (ownerInDatabase) {
+ // 如果站长在数据库中，获取详细信息
+ ownerInfo = await this.getUserInfoV2(ownerUsername);
+ }
+ } else {
+ // 缓存未命中，查询数据库
+ ownerInfo = await this.getUserInfoV2(ownerUsername);
+ ownerInDatabase = !!ownerInfo;
+ // 更新缓存
+ ownerExistenceCache.set(ownerUsername, ownerInDatabase);
+ }
+
+ // 如果站长不在数据库中，总数+1（无论在哪一页都要加）
+ if (!ownerInDatabase) {
+ total += 1;
+ }
+ }
+
+ // 如果站长不在数据库中且在第一页，需要调整获取的用户数量和偏移量
+ let actualOffset = offset;
+ let actualLimit = limit;
+
+ if (ownerUsername && !ownerInDatabase) {
+ if (offset === 0) {
+ // 第一页：只获取 limit-1 个用户，为站长留出位置
+ actualLimit = limit - 1;
+ } else {
+ // 其他页：偏移量需要减1，因为站长占据了第一页的一个位置
+ actualOffset = offset - 1;
+ }
+ }
+
+ // 获取用户列表（按注册时间升序）
+ const usernames = await this.withRetry(() =>
+ this.client.zRange(this.userListKey(), actualOffset, actualOffset + actualLimit - 1)
+ );
+
+ const users = [];
+
+ // 如果有站长且在第一页，确保站长始终在第一位
+ if (ownerUsername && offset === 0) {
+ // 即使站长不在数据库中，也要添加站长（站长使用环境变量认证）
+ users.push({
+ username: ownerUsername,
+ role: 'owner' as const,
+ banned: ownerInfo?.banned || false,
+ tags: ownerInfo?.tags,
+ created_at: ownerInfo?.created_at || 0,
+ });
+ }
+
+ // 获取其他用户信息
+ for (const username of usernames) {
+ const usernameStr = ensureString(username);
+ // 跳过站长（已经添加）
+ if (ownerUsername && usernameStr === ownerUsername) {
+ continue;
+ }
+
+ const userInfo = await this.getUserInfoV2(usernameStr);
+ if (userInfo) {
+ users.push({
+ username: usernameStr,
+ role: userInfo.role,
+ banned: userInfo.banned,
+ tags: userInfo.tags,
+ created_at: userInfo.created_at,
+ });
+ }
+ }
+
+ return { users, total };
+ }
+
+ // 删除用户（新版本）
+ async deleteUserV2(userName: string): Promise {
+ // 获取用户信息
+ const userInfo = await this.getUserInfoV2(userName);
+
+ // 删除OIDC映射
+ if (userInfo?.oidcSub) {
+ await this.withRetry(() => this.client.del(this.oidcSubKey(userInfo.oidcSub!)));
+ }
+
+ // 删除用户信息Hash
+ await this.withRetry(() => this.client.del(this.userInfoKey(userName)));
+
+ // 从用���列表中移除
+ await this.withRetry(() => this.client.zRem(this.userListKey(), userName));
+
+ // 删除用户的其他数据（播放记录、收藏等）
+ await this.deleteUser(userName);
+ }
+
// ---------- 搜索历史 ----------
private shKey(user: string) {
return `u:${user}:sh`; // u:username:sh
@@ -348,13 +664,20 @@ export abstract class BaseRedisStorage implements IStorage {
// ---------- 获取全部用户 ----------
async getAllUsers(): Promise {
- const keys = await this.withRetry(() => this.client.keys('u:*:pwd'));
- return keys
- .map((k) => {
- const match = k.match(/^u:(.+?):pwd$/);
- return match ? ensureString(match[1]) : undefined;
- })
- .filter((u): u is string => typeof u === 'string');
+ // 从新版用户列表获取
+ const userListKey = this.userListKey();
+ const users = await this.withRetry(() =>
+ this.client.zRange(userListKey, 0, -1)
+ );
+ const userList = users.map(u => ensureString(u));
+
+ // 确保站长在列表中（站长可能不在数据库中，使用环境变量认证）
+ const ownerUsername = process.env.USERNAME;
+ if (ownerUsername && !userList.includes(ownerUsername)) {
+ userList.unshift(ownerUsername);
+ }
+
+ return userList;
}
// ---------- 管理员配置 ----------
diff --git a/src/lib/scan-task.ts b/src/lib/scan-task.ts
new file mode 100644
index 0000000..ec06c6b
--- /dev/null
+++ b/src/lib/scan-task.ts
@@ -0,0 +1,131 @@
+/* eslint-disable @typescript-eslint/no-explicit-any, no-console */
+
+/**
+ * 后台扫描任务管理
+ */
+
+export interface ScanTask {
+ id: string;
+ status: 'running' | 'completed' | 'failed';
+ progress: {
+ current: number;
+ total: number;
+ currentFolder?: string;
+ };
+ result?: {
+ total: number;
+ new: number;
+ existing: number;
+ errors: number;
+ };
+ error?: string;
+ startTime: number;
+ endTime?: number;
+}
+
+const tasks = new Map();
+
+export function createScanTask(): string {
+ const id = `scan_${Date.now()}_${Math.random().toString(36).substring(7)}`;
+ const task: ScanTask = {
+ id,
+ status: 'running',
+ progress: {
+ current: 0,
+ total: 0,
+ },
+ startTime: Date.now(),
+ };
+ tasks.set(id, task);
+ return id;
+}
+
+export function getScanTask(id: string): ScanTask | null {
+ return tasks.get(id) || null;
+}
+
+export function updateScanTaskProgress(
+ id: string,
+ current: number,
+ total: number,
+ currentFolder?: string
+): void {
+ let task = tasks.get(id);
+ if (!task) {
+ // 如果任务不存在（可能因为模块重新加载），重新创建任务
+ console.warn(`[ScanTask] 任务 ${id} 不存在，重新创建`);
+ task = {
+ id,
+ status: 'running',
+ progress: {
+ current: 0,
+ total: 0,
+ },
+ startTime: Date.now(),
+ };
+ tasks.set(id, task);
+ }
+ task.progress = { current, total, currentFolder };
+}
+
+export function completeScanTask(
+ id: string,
+ result: ScanTask['result']
+): void {
+ let task = tasks.get(id);
+ if (!task) {
+ // 如果任务不存在（可能因为模块重新加载），重新创建任务
+ console.warn(`[ScanTask] 任务 ${id} 不存在，重新创建并标记为完成`);
+ task = {
+ id,
+ status: 'completed',
+ progress: {
+ current: result?.total || 0,
+ total: result?.total || 0,
+ },
+ startTime: Date.now() - 60000, // 假设任务运行了1分钟
+ endTime: Date.now(),
+ result,
+ };
+ tasks.set(id, task);
+ return;
+ }
+ task.status = 'completed';
+ task.result = result;
+ task.endTime = Date.now();
+}
+
+export function failScanTask(id: string, error: string): void {
+ let task = tasks.get(id);
+ if (!task) {
+ // 如果任务不存在（可能因为模块重新加载），重新创建任务
+ console.warn(`[ScanTask] 任务 ${id} 不存在，重新创建并标记为失败`);
+ task = {
+ id,
+ status: 'failed',
+ progress: {
+ current: 0,
+ total: 0,
+ },
+ startTime: Date.now() - 60000, // 假设任务运行了1分钟
+ endTime: Date.now(),
+ error,
+ };
+ tasks.set(id, task);
+ return;
+ }
+ task.status = 'failed';
+ task.error = error;
+ task.endTime = Date.now();
+}
+
+export function cleanupOldTasks(): void {
+ const now = Date.now();
+ const maxAge = 60 * 60 * 1000; // 1小时
+
+ for (const [id, task] of Array.from(tasks.entries())) {
+ if (task.endTime && now - task.endTime > maxAge) {
+ tasks.delete(id);
+ }
+ }
+}
diff --git a/src/lib/tmdb.client.ts b/src/lib/tmdb.client.ts
index a72cc9e..d5f4ff6 100644
--- a/src/lib/tmdb.client.ts
+++ b/src/lib/tmdb.client.ts
@@ -1,5 +1,8 @@
/* eslint-disable @typescript-eslint/no-explicit-any,no-console */
+import { HttpsProxyAgent } from 'https-proxy-agent';
+import nodeFetch from 'node-fetch';
+
export interface TMDBMovie {
id: number;
title: string;
@@ -48,28 +51,42 @@ interface TMDBTVAiringTodayResponse {
* @param apiKey - TMDB API Key
* @param page - 页码
* @param region - 地区代码，默认 CN (中国)
+ * @param proxy - 代理服务器地址
* @returns 即将上映的电影列表
*/
export async function getTMDBUpcomingMovies(
apiKey: string,
page: number = 1,
- region: string = 'CN'
+ region: string = 'CN',
+ proxy?: string
): Promise<{ code: number; list: TMDBMovie[] }> {
try {
if (!apiKey) {
return { code: 400, list: [] };
}
- const response = await fetch(
- `https://api.themoviedb.org/3/movie/upcoming?api_key=${apiKey}&language=zh-CN&page=${page}®ion=${region}`
- );
+ const url = `https://api.themoviedb.org/3/movie/upcoming?api_key=${apiKey}&language=zh-CN&page=${page}®ion=${region}`;
+ const fetchOptions: any = proxy
+ ? {
+ agent: new HttpsProxyAgent(proxy, {
+ timeout: 30000,
+ keepAlive: false,
+ }),
+ signal: AbortSignal.timeout(30000),
+ }
+ : {
+ signal: AbortSignal.timeout(15000),
+ };
+
+ // 使用 node-fetch 而不是原生 fetch
+ const response = await nodeFetch(url, fetchOptions);
if (!response.ok) {
console.error('TMDB API 请求失败:', response.status, response.statusText);
return { code: response.status, list: [] };
}
- const data: TMDBUpcomingResponse = await response.json();
+ const data: TMDBUpcomingResponse = await response.json() as TMDBUpcomingResponse;
return {
code: 200,
@@ -85,11 +102,13 @@ export async function getTMDBUpcomingMovies(
* 获取正在播出的电视剧
* @param apiKey - TMDB API Key
* @param page - 页码
+ * @param proxy - 代理服务器地址
* @returns 正在播出的电视剧列表
*/
export async function getTMDBUpcomingTVShows(
apiKey: string,
- page: number = 1
+ page: number = 1,
+ proxy?: string
): Promise<{ code: number; list: TMDBTVShow[] }> {
try {
if (!apiKey) {
@@ -97,16 +116,28 @@ export async function getTMDBUpcomingTVShows(
}
// 使用 on_the_air 接口获取正在播出的电视剧
- const response = await fetch(
- `https://api.themoviedb.org/3/tv/on_the_air?api_key=${apiKey}&language=zh-CN&page=${page}`
- );
+ const url = `https://api.themoviedb.org/3/tv/on_the_air?api_key=${apiKey}&language=zh-CN&page=${page}`;
+ const fetchOptions: any = proxy
+ ? {
+ agent: new HttpsProxyAgent(proxy, {
+ timeout: 30000,
+ keepAlive: false,
+ }),
+ signal: AbortSignal.timeout(30000),
+ }
+ : {
+ signal: AbortSignal.timeout(15000),
+ };
+
+ // 使用 node-fetch 而不是原生 fetch
+ const response = await nodeFetch(url, fetchOptions);
if (!response.ok) {
console.error('TMDB TV API 请求失败:', response.status, response.statusText);
return { code: response.status, list: [] };
}
- const data: TMDBTVAiringTodayResponse = await response.json();
+ const data: TMDBTVAiringTodayResponse = await response.json() as TMDBTVAiringTodayResponse;
return {
code: 200,
@@ -121,10 +152,12 @@ export async function getTMDBUpcomingTVShows(
/**
* 获取即将上映/播出的内容（电影+电视剧）
* @param apiKey - TMDB API Key
+ * @param proxy - 代理服务器地址
* @returns 统一格式的即将上映/播出列表
*/
export async function getTMDBUpcomingContent(
- apiKey: string
+ apiKey: string,
+ proxy?: string
): Promise<{ code: number; list: TMDBItem[] }> {
try {
if (!apiKey) {
@@ -133,8 +166,8 @@ export async function getTMDBUpcomingContent(
// 并行获取电影和电视剧数据
const [moviesResult, tvShowsResult] = await Promise.all([
- getTMDBUpcomingMovies(apiKey),
- getTMDBUpcomingTVShows(apiKey),
+ getTMDBUpcomingMovies(apiKey, 1, 'CN', proxy),
+ getTMDBUpcomingTVShows(apiKey, 1, proxy),
]);
// 检查是否有错误
diff --git a/src/lib/tmdb.search.ts b/src/lib/tmdb.search.ts
new file mode 100644
index 0000000..b35ec27
--- /dev/null
+++ b/src/lib/tmdb.search.ts
@@ -0,0 +1,91 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import { HttpsProxyAgent } from 'https-proxy-agent';
+import nodeFetch from 'node-fetch';
+
+export interface TMDBSearchResult {
+ id: number;
+ title?: string; // 电影
+ name?: string; // 电视剧
+ poster_path: string | null;
+ release_date?: string;
+ first_air_date?: string;
+ overview: string;
+ vote_average: number;
+ media_type: 'movie' | 'tv';
+}
+
+interface TMDBSearchResponse {
+ results: TMDBSearchResult[];
+ page: number;
+ total_pages: number;
+ total_results: number;
+}
+
+/**
+ * 搜索 TMDB (电影+电视剧)
+ */
+export async function searchTMDB(
+ apiKey: string,
+ query: string,
+ proxy?: string
+): Promise<{ code: number; result: TMDBSearchResult | null }> {
+ try {
+ if (!apiKey) {
+ return { code: 400, result: null };
+ }
+
+ // 使用 multi search 同时搜索电影和电视剧
+ const url = `https://api.themoviedb.org/3/search/multi?api_key=${apiKey}&language=zh-CN&query=${encodeURIComponent(query)}&page=1`;
+
+ const fetchOptions: any = proxy
+ ? {
+ agent: new HttpsProxyAgent(proxy, {
+ timeout: 30000,
+ keepAlive: false,
+ }),
+ signal: AbortSignal.timeout(30000),
+ }
+ : {
+ signal: AbortSignal.timeout(15000),
+ };
+
+ // 使用 node-fetch 而不是原生 fetch，因为原生 fetch 不支持 agent 选项
+ const response = await nodeFetch(url, fetchOptions);
+
+ if (!response.ok) {
+ console.error('TMDB 搜索失败:', response.status, response.statusText);
+ return { code: response.status, result: null };
+ }
+
+ const data: TMDBSearchResponse = await response.json() as TMDBSearchResponse;
+
+ // 过滤出电影和电视剧，取第一个结果
+ const validResults = data.results.filter(
+ (item) => item.media_type === 'movie' || item.media_type === 'tv'
+ );
+
+ if (validResults.length === 0) {
+ return { code: 404, result: null };
+ }
+
+ return {
+ code: 200,
+ result: validResults[0],
+ };
+ } catch (error) {
+ console.error('TMDB 搜索异常:', error);
+ return { code: 500, result: null };
+ }
+}
+
+/**
+ * 获取 TMDB 图片完整 URL
+ */
+export function getTMDBImageUrl(
+ path: string | null,
+ size: string = 'w500'
+): string {
+ if (!path) return '';
+ return `https://image.tmdb.org/t/p/${size}${path}`;
+}
diff --git a/src/lib/upstash.db.ts b/src/lib/upstash.db.ts
index a274f43..830f259 100644
--- a/src/lib/upstash.db.ts
+++ b/src/lib/upstash.db.ts
@@ -4,6 +4,7 @@ import { Redis } from '@upstash/redis';
import { AdminConfig } from './admin.types';
import { Favorite, IStorage, PlayRecord, SkipConfig } from './types';
+import { userInfoCache } from './user-cache';
// 搜索历史最大条数
const SEARCH_HISTORY_LIMIT = 20;
@@ -220,6 +221,424 @@ export class UpstashRedisStorage implements IStorage {
}
}
+ // ---------- 新版用户存储（使用Hash和Sorted Set） ----------
+ private userInfoKey(userName: string) {
+ return `user:${userName}:info`;
+ }
+
+ private userListKey() {
+ return 'user:list';
+ }
+
+ private oidcSubKey(oidcSub: string) {
+ return `oidc:sub:${oidcSub}`;
+ }
+
+ // SHA256加密密码
+ private async hashPassword(password: string): Promise {
+ const encoder = new TextEncoder();
+ const data = encoder.encode(password);
+ const hashBuffer = await crypto.subtle.digest('SHA-256', data);
+ const hashArray = Array.from(new Uint8Array(hashBuffer));
+ return hashArray.map(b => b.toString(16).padStart(2, '0')).join('');
+ }
+
+ // 创建新用户（新版本）
+ async createUserV2(
+ userName: string,
+ password: string,
+ role: 'owner' | 'admin' | 'user' = 'user',
+ tags?: string[],
+ oidcSub?: string,
+ enabledApis?: string[]
+ ): Promise {
+ // 先检查用户是否已存在（原子性检查）
+ const exists = await withRetry(() =>
+ this.client.exists(this.userInfoKey(userName))
+ );
+ if (exists === 1) {
+ throw new Error('用户已存在');
+ }
+
+ const hashedPassword = await this.hashPassword(password);
+ const createdAt = Date.now();
+
+ // 存储用户信息到Hash
+ const userInfo: Record = {
+ role,
+ banned: false, // 直接使用布尔值
+ password: hashedPassword,
+ created_at: createdAt.toString(),
+ };
+
+ if (tags && tags.length > 0) {
+ userInfo.tags = JSON.stringify(tags);
+ }
+
+ if (oidcSub) {
+ userInfo.oidcSub = oidcSub;
+ // 创建OIDC映射
+ await withRetry(() => this.client.set(this.oidcSubKey(oidcSub), userName));
+ }
+
+ if (enabledApis && enabledApis.length > 0) {
+ userInfo.enabledApis = JSON.stringify(enabledApis);
+ }
+
+ await withRetry(() => this.client.hset(this.userInfoKey(userName), userInfo));
+
+ // 添加到用户列表（Sorted Set，按注册时间排序）
+ await withRetry(() => this.client.zadd(this.userListKey(), {
+ score: createdAt,
+ member: userName,
+ }));
+
+ // 如果创建的是站长用户，清除站长存在状态缓存
+ if (userName === process.env.USERNAME) {
+ const { ownerExistenceCache } = await import('./user-cache');
+ ownerExistenceCache.delete(userName);
+ }
+ }
+
+ // 验证用户密码（新版本）
+ async verifyUserV2(userName: string, password: string): Promise {
+ const userInfo = await withRetry(() =>
+ this.client.hgetall(this.userInfoKey(userName))
+ );
+
+ if (!userInfo || !userInfo.password) {
+ return false;
+ }
+
+ const hashedPassword = await this.hashPassword(password);
+ return userInfo.password === hashedPassword;
+ }
+
+ // 获取用户信息（新版本）
+ async getUserInfoV2(userName: string): Promise<{
+ role: 'owner' | 'admin' | 'user';
+ banned: boolean;
+ tags?: string[];
+ oidcSub?: string;
+ enabledApis?: string[];
+ created_at: number;
+ } | null> {
+ // 先从缓存获取
+ const cached = userInfoCache?.get(userName);
+ if (cached) {
+ return cached;
+ }
+
+ const userInfo = await withRetry(() =>
+ this.client.hgetall(this.userInfoKey(userName))
+ );
+
+ if (!userInfo || Object.keys(userInfo).length === 0) {
+ return null;
+ }
+
+ // 处理 banned 字段：可能是字符串 'true'/'false' 或布尔值 true/false
+ let banned = false;
+ if (typeof userInfo.banned === 'boolean') {
+ banned = userInfo.banned;
+ } else if (typeof userInfo.banned === 'string') {
+ banned = userInfo.banned === 'true';
+ }
+
+ // 安全解析 tags 字段
+ let tags: string[] | undefined = undefined;
+ if (userInfo.tags) {
+ if (Array.isArray(userInfo.tags)) {
+ tags = userInfo.tags;
+ } else if (typeof userInfo.tags === 'string') {
+ try {
+ tags = JSON.parse(userInfo.tags);
+ } catch {
+ // 如果解析失败，可能是单个字符串，转换为数组
+ tags = [userInfo.tags];
+ }
+ }
+ }
+
+ // 安全解析 enabledApis 字段
+ let enabledApis: string[] | undefined = undefined;
+ if (userInfo.enabledApis) {
+ if (Array.isArray(userInfo.enabledApis)) {
+ enabledApis = userInfo.enabledApis;
+ } else if (typeof userInfo.enabledApis === 'string') {
+ try {
+ enabledApis = JSON.parse(userInfo.enabledApis);
+ } catch {
+ // 如果解析失败，可能是单个字符串，转换为数组
+ enabledApis = [userInfo.enabledApis];
+ }
+ }
+ }
+
+ const result = {
+ role: (userInfo.role as 'owner' | 'admin' | 'user') || 'user',
+ banned,
+ tags,
+ oidcSub: userInfo.oidcSub as string | undefined,
+ enabledApis,
+ created_at: parseInt((userInfo.created_at as string) || '0', 10),
+ };
+
+ // 存入缓存
+ userInfoCache?.set(userName, result);
+
+ return result;
+ }
+
+ // 更新用户信息（新版本）
+ async updateUserInfoV2(
+ userName: string,
+ updates: {
+ role?: 'owner' | 'admin' | 'user';
+ banned?: boolean;
+ tags?: string[];
+ oidcSub?: string;
+ enabledApis?: string[];
+ }
+ ): Promise {
+ const userInfo: Record = {};
+
+ if (updates.role !== undefined) {
+ userInfo.role = updates.role;
+ }
+
+ if (updates.banned !== undefined) {
+ // 直接存储布尔值，让 Upstash 自动处理序列化
+ userInfo.banned = updates.banned;
+ }
+
+ if (updates.tags !== undefined) {
+ if (updates.tags.length > 0) {
+ userInfo.tags = JSON.stringify(updates.tags);
+ } else {
+ // 删除tags字段
+ await withRetry(() => this.client.hdel(this.userInfoKey(userName), 'tags'));
+ }
+ }
+
+ if (updates.enabledApis !== undefined) {
+ if (updates.enabledApis.length > 0) {
+ userInfo.enabledApis = JSON.stringify(updates.enabledApis);
+ } else {
+ // 删除enabledApis字段
+ await withRetry(() => this.client.hdel(this.userInfoKey(userName), 'enabledApis'));
+ }
+ }
+
+ if (updates.oidcSub !== undefined) {
+ const oldInfo = await this.getUserInfoV2(userName);
+ if (oldInfo?.oidcSub && oldInfo.oidcSub !== updates.oidcSub) {
+ // 删除旧的OIDC映射
+ await withRetry(() => this.client.del(this.oidcSubKey(oldInfo.oidcSub!)));
+ }
+ userInfo.oidcSub = updates.oidcSub;
+ // 创建新的OIDC映射
+ await withRetry(() => this.client.set(this.oidcSubKey(updates.oidcSub!), userName));
+ }
+
+ if (Object.keys(userInfo).length > 0) {
+ await withRetry(() => this.client.hset(this.userInfoKey(userName), userInfo));
+ }
+
+ // 清除缓存
+ userInfoCache?.delete(userName);
+ }
+
+ // 修改用户密码（新版本）
+ async changePasswordV2(userName: string, newPassword: string): Promise {
+ const hashedPassword = await this.hashPassword(newPassword);
+ await withRetry(() =>
+ this.client.hset(this.userInfoKey(userName), { password: hashedPassword })
+ );
+
+ // 清除缓存
+ userInfoCache?.delete(userName);
+ }
+
+ // 检查用户是否存在（新版本）
+ async checkUserExistV2(userName: string): Promise {
+ const exists = await withRetry(() =>
+ this.client.exists(this.userInfoKey(userName))
+ );
+ return exists === 1;
+ }
+
+ // 通过OIDC Sub查找用户名
+ async getUserByOidcSub(oidcSub: string): Promise {
+ const userName = await withRetry(() =>
+ this.client.get(this.oidcSubKey(oidcSub))
+ );
+ return userName ? ensureString(userName) : null;
+ }
+
+ // 获取使用特定用户组的用户列表
+ async getUsersByTag(tagName: string): Promise {
+ const affectedUsers: string[] = [];
+
+ // 使用 SCAN 遍历所有用户信息的 key
+ let cursor: number | string = 0;
+ do {
+ const result = await withRetry(() =>
+ this.client.scan(cursor as number, { match: 'user:*:info', count: 100 })
+ );
+
+ cursor = result[0];
+ const keys = result[1];
+
+ // 检查每个用户的 tags
+ for (const key of keys) {
+ const userInfo = await withRetry(() => this.client.hgetall(key));
+ if (userInfo && userInfo.tags) {
+ const tags = JSON.parse(userInfo.tags as string);
+ if (tags.includes(tagName)) {
+ // 从 key 中提取用户名: user:username:info -> username
+ const username = key.replace('user:', '').replace(':info', '');
+ affectedUsers.push(username);
+ }
+ }
+ }
+ } while (typeof cursor === 'number' ? cursor !== 0 : cursor !== '0');
+
+ return affectedUsers;
+ }
+
+ // 获取用户列表（分页，新版本）
+ async getUserListV2(
+ offset: number = 0,
+ limit: number = 20,
+ ownerUsername?: string
+ ): Promise<{
+ users: Array<{
+ username: string;
+ role: 'owner' | 'admin' | 'user';
+ banned: boolean;
+ tags?: string[];
+ oidcSub?: string;
+ enabledApis?: string[];
+ created_at: number;
+ }>;
+ total: number;
+ }> {
+ // 获取总数
+ let total = await withRetry(() => this.client.zcard(this.userListKey()));
+
+ // 检查站长是否在数据库中（使用缓存）
+ let ownerInfo = null;
+ let ownerInDatabase = false;
+ if (ownerUsername) {
+ // 先检查缓存
+ const { ownerExistenceCache } = await import('./user-cache');
+ const cachedExists = ownerExistenceCache.get(ownerUsername);
+
+ if (cachedExists !== null) {
+ // 使用缓存的结果
+ ownerInDatabase = cachedExists;
+ if (ownerInDatabase) {
+ // 如果站长在数据库中，获取详细信息
+ ownerInfo = await this.getUserInfoV2(ownerUsername);
+ }
+ } else {
+ // 缓存未命中，查询数据库
+ ownerInfo = await this.getUserInfoV2(ownerUsername);
+ ownerInDatabase = !!ownerInfo;
+ // 更���缓存
+ ownerExistenceCache.set(ownerUsername, ownerInDatabase);
+ }
+
+ // 如果站长不在数据库中，总数+1（无论在哪一页都要加）
+ if (!ownerInDatabase) {
+ total += 1;
+ }
+ }
+
+ // 如果站长不在数据库中且在第一页，需要调整获取的用户数量和偏移量
+ let actualOffset = offset;
+ let actualLimit = limit;
+
+ if (ownerUsername && !ownerInDatabase) {
+ if (offset === 0) {
+ // 第一页：只获取 limit-1 个用户，为站长留出位置
+ actualLimit = limit - 1;
+ } else {
+ // 其他页：偏移量需要减1，因为站长占据了第一页的一个位置
+ actualOffset = offset - 1;
+ }
+ }
+
+ // 获取用户列表（按注册时间升序）
+ const usernames = await withRetry(() =>
+ this.client.zrange(this.userListKey(), actualOffset, actualOffset + actualLimit - 1)
+ );
+
+ const users = [];
+
+ // 如果有站长且在第一页，确保站长始终在第一位
+ if (ownerUsername && offset === 0) {
+ // 即使站长不在数据库中，也要添加站长（站长使用环境变量认证）
+ users.push({
+ username: ownerUsername,
+ role: 'owner' as const,
+ banned: ownerInfo?.banned || false,
+ tags: ownerInfo?.tags,
+ oidcSub: ownerInfo?.oidcSub,
+ enabledApis: ownerInfo?.enabledApis,
+ created_at: ownerInfo?.created_at || 0,
+ });
+ }
+
+ // 获取其他用户信息
+ for (const username of usernames) {
+ const usernameStr = ensureString(username);
+ // 跳过站长（已经添加）
+ if (ownerUsername && usernameStr === ownerUsername) {
+ continue;
+ }
+
+ const userInfo = await this.getUserInfoV2(usernameStr);
+ if (userInfo) {
+ users.push({
+ username: usernameStr,
+ role: userInfo.role,
+ banned: userInfo.banned,
+ tags: userInfo.tags,
+ oidcSub: userInfo.oidcSub,
+ enabledApis: userInfo.enabledApis,
+ created_at: userInfo.created_at,
+ });
+ }
+ }
+
+ return { users, total };
+ }
+
+ // 删除用户（新版本）
+ async deleteUserV2(userName: string): Promise {
+ // 获取用户信息
+ const userInfo = await this.getUserInfoV2(userName);
+
+ // 删除OIDC映射
+ if (userInfo?.oidcSub) {
+ await withRetry(() => this.client.del(this.oidcSubKey(userInfo.oidcSub!)));
+ }
+
+ // 删除用户信息Hash
+ await withRetry(() => this.client.del(this.userInfoKey(userName)));
+
+ // 从用户列表中移除
+ await withRetry(() => this.client.zrem(this.userListKey(), userName));
+
+ // 删除用户的其他数据（播放记录、收藏等）
+ await this.deleteUser(userName);
+
+ // 清除缓存
+ userInfoCache?.delete(userName);
+ }
+
// ---------- 搜索历史 ----------
private shKey(user: string) {
return `u:${user}:sh`; // u:username:sh
@@ -254,13 +673,20 @@ export class UpstashRedisStorage implements IStorage {
// ---------- 获取全部用户 ----------
async getAllUsers(): Promise {
- const keys = await withRetry(() => this.client.keys('u:*:pwd'));
- return keys
- .map((k) => {
- const match = k.match(/^u:(.+?):pwd$/);
- return match ? ensureString(match[1]) : undefined;
- })
- .filter((u): u is string => typeof u === 'string');
+ // 从新版用户列表获取
+ const userListKey = this.userListKey();
+ const users = await withRetry(() =>
+ this.client.zrange(userListKey, 0, -1)
+ );
+ const userList = users.map(u => ensureString(u));
+
+ // 确保站长在列表中（站长可能不在数据库中，使用环境变量认证）
+ const ownerUsername = process.env.USERNAME;
+ if (ownerUsername && !userList.includes(ownerUsername)) {
+ userList.unshift(ownerUsername);
+ }
+
+ return userList;
}
// ---------- 管理员配置 ----------
diff --git a/src/lib/user-cache.ts b/src/lib/user-cache.ts
new file mode 100644
index 0000000..f1ec2f3
--- /dev/null
+++ b/src/lib/user-cache.ts
@@ -0,0 +1,132 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+// 用户信息缓存
+interface CachedUserInfo {
+ role: 'owner' | 'admin' | 'user';
+ banned: boolean;
+ tags?: string[];
+ oidcSub?: string;
+ enabledApis?: string[];
+ created_at: number;
+ cachedAt: number;
+}
+
+class UserInfoCache {
+ private cache: Map = new Map();
+ private readonly TTL = 6 * 60 * 60 * 1000; // 6小时过期
+
+ get(username: string): CachedUserInfo | null {
+ const cached = this.cache.get(username);
+ if (!cached) return null;
+
+ // 检查是否过期
+ if (Date.now() - cached.cachedAt > this.TTL) {
+ this.cache.delete(username);
+ return null;
+ }
+
+ return cached;
+ }
+
+ set(username: string, userInfo: Omit): void {
+ this.cache.set(username, {
+ ...userInfo,
+ cachedAt: Date.now(),
+ });
+ }
+
+ delete(username: string): void {
+ this.cache.delete(username);
+ }
+
+ clear(): void {
+ this.cache.clear();
+ }
+
+ // 清理过期的缓存
+ cleanup(): void {
+ const now = Date.now();
+ const entries = Array.from(this.cache.entries());
+ for (const [username, cached] of entries) {
+ if (now - cached.cachedAt > this.TTL) {
+ this.cache.delete(username);
+ }
+ }
+ }
+}
+
+// 站长存在状态缓存
+class OwnerExistenceCache {
+ private cache: Map = new Map();
+ private readonly TTL = 10 * 60 * 1000; // 10分钟过期
+
+ get(ownerUsername: string): boolean | null {
+ const cached = this.cache.get(ownerUsername);
+ if (!cached) return null;
+
+ // 检查是否过期
+ if (Date.now() - cached.cachedAt > this.TTL) {
+ this.cache.delete(ownerUsername);
+ return null;
+ }
+
+ return cached.exists;
+ }
+
+ set(ownerUsername: string, exists: boolean): void {
+ this.cache.set(ownerUsername, {
+ exists,
+ cachedAt: Date.now(),
+ });
+ }
+
+ delete(ownerUsername: string): void {
+ this.cache.delete(ownerUsername);
+ }
+
+ clear(): void {
+ this.cache.clear();
+ }
+
+ // 清理过期的缓存
+ cleanup(): void {
+ const now = Date.now();
+ const entries = Array.from(this.cache.entries());
+ for (const [username, cached] of entries) {
+ if (now - cached.cachedAt > this.TTL) {
+ this.cache.delete(username);
+ }
+ }
+ }
+}
+
+// 全局单例
+const globalKey = Symbol.for('__MOONTV_USER_INFO_CACHE__');
+let _userInfoCache: UserInfoCache | undefined = (global as any)[globalKey];
+
+if (!_userInfoCache) {
+ _userInfoCache = new UserInfoCache();
+ (global as any)[globalKey] = _userInfoCache;
+
+ // 每分钟清理一次过期缓存
+ setInterval(() => {
+ _userInfoCache?.cleanup();
+ }, 60 * 1000);
+}
+
+export const userInfoCache = _userInfoCache as UserInfoCache;
+
+const ownerExistenceGlobalKey = Symbol.for('__MOONTV_OWNER_EXISTENCE_CACHE__');
+let _ownerExistenceCache: OwnerExistenceCache | undefined = (global as any)[ownerExistenceGlobalKey];
+
+if (!_ownerExistenceCache) {
+ _ownerExistenceCache = new OwnerExistenceCache();
+ (global as any)[ownerExistenceGlobalKey] = _ownerExistenceCache;
+
+ // 每分钟清理一次过期缓存
+ setInterval(() => {
+ _ownerExistenceCache?.cleanup();
+ }, 60 * 1000);
+}
+
+export const ownerExistenceCache = _ownerExistenceCache as OwnerExistenceCache;
diff --git a/src/lib/version.ts b/src/lib/version.ts
index 607ddb9..2888093 100644
--- a/src/lib/version.ts
+++ b/src/lib/version.ts
@@ -1,6 +1,6 @@
/* eslint-disable no-console */
-const CURRENT_VERSION = '203.2.2';
+const CURRENT_VERSION = '204.0.0';
// 导出当前版本号供其他地方使用
export { CURRENT_VERSION };
diff --git a/src/lib/video-parser.ts b/src/lib/video-parser.ts
new file mode 100644
index 0000000..0f3d723
--- /dev/null
+++ b/src/lib/video-parser.ts
@@ -0,0 +1,57 @@
+import parseTorrentName from 'parse-torrent-name';
+
+export interface ParsedVideoInfo {
+ episode?: number;
+ season?: number;
+ title?: string;
+}
+
+/**
+ * 解析视频文件名
+ */
+export function parseVideoFileName(fileName: string): ParsedVideoInfo {
+ try {
+ const parsed = parseTorrentName(fileName);
+
+ // 如果 parse-torrent-name 成功解析出集数，直接返回
+ if (parsed.episode) {
+ return {
+ episode: parsed.episode,
+ season: parsed.season,
+ title: parsed.title,
+ };
+ }
+ } catch (error) {
+ console.error('parse-torrent-name 解析失败:', fileName, error);
+ }
+
+ // 降级方案：使用多种正则模式提取集数
+ // 按优先级排序：更具体的模式优先
+ const patterns = [
+ // S01E01, s01e01, S01E01.5 (支持小数) - 最具体
+ /[Ss]\d+[Ee](\d+(?:\.\d+)?)/,
+ // [01], (01), [01.5], (01.5) (支持小数) - 很具体
+ /[\[\(](\d+(?:\.\d+)?)[\]\)]/,
+ // E01, E1, e01, e1, E01.5 (支持小数)
+ /[Ee](\d+(?:\.\d+)?)/,
+ // 第01集, 第1集, 第01话, 第1话, 第1.5集 (支持小数)
+ /第(\d+(?:\.\d+)?)[集话]/,
+ // _01_, -01-, _01.5_, -01.5- (支持小数)
+ /[_\-](\d+(?:\.\d+)?)[_\-]/,
+ // 01.mp4, 001.mp4, 01.5.mp4 (纯数字开头，支持小数) - 最不具体
+ /^(\d+(?:\.\d+)?)[^\d.]/,
+ ];
+
+ for (const pattern of patterns) {
+ const match = fileName.match(pattern);
+ if (match && match[1]) {
+ const episode = parseFloat(match[1]);
+ if (episode > 0 && episode < 10000) { // 合理的集数范围
+ return { episode };
+ }
+ }
+ }
+
+ // 如果所有模式都失败，返回空对象（调用方会处理）
+ return {};
+}
diff --git a/src/types/parse-torrent-name.d.ts b/src/types/parse-torrent-name.d.ts
new file mode 100644
index 0000000..9991c07
--- /dev/null
+++ b/src/types/parse-torrent-name.d.ts
@@ -0,0 +1,30 @@
+declare module 'parse-torrent-name' {
+ interface ParsedTorrent {
+ title?: string;
+ season?: number;
+ episode?: number;
+ year?: number;
+ resolution?: string;
+ codec?: string;
+ audio?: string;
+ group?: string;
+ region?: string;
+ extended?: boolean;
+ hardcoded?: boolean;
+ proper?: boolean;
+ repack?: boolean;
+ container?: string;
+ widescreen?: boolean;
+ website?: string;
+ language?: string;
+ sbs?: string;
+ unrated?: boolean;
+ size?: string;
+ bitDepth?: string;
+ hdr?: boolean;
+ [key: string]: unknown;
+ }
+
+ function parseTorrentName(name: string): ParsedTorrent;
+ export default parseTorrentName;
+}