uc网盘在线播放

2026-04-27 15:44:17 +08:00
parent 2a0900ab69
commit cf3176ae9c
15 changed files with 1251 additions and 17 deletions
@@ -170,6 +170,12 @@ export interface AdminConfig {
      Account: string;
      Password: string;
    };
+    UC?: {
+      Enabled: boolean;
+      Cookie: string;
+      Token?: string;
+      SavePath: string;
+    };
  };
  AIConfig?: {
    Enabled: boolean; // 是否启用AI问片功能
@@ -688,6 +688,12 @@ export function configSelfCheck(adminConfig: AdminConfig): AdminConfig {
        Account: '',
        Password: '',
      },
+      UC: {
+        Enabled: false,
+        Cookie: '',
+        Token: '',
+        SavePath: '/',
+      },
    };
  }

@@ -729,6 +735,15 @@ export function configSelfCheck(adminConfig: AdminConfig): AdminConfig {
    };
  }

+  if (!adminConfig.NetDiskConfig.UC) {
+    adminConfig.NetDiskConfig.UC = {
+      Enabled: false,
+      Cookie: '',
+      Token: '',
+      SavePath: '/',
+    };
+  }
+
  // 确保音乐配置存在
  if (!adminConfig.MusicConfig) {
    adminConfig.MusicConfig = {
@@ -4,8 +4,9 @@ export const NETDISK_MOBILE_SOURCE = 'netdisk-mobile';
 export const NETDISK_BAIDU_SOURCE = 'netdisk-baidu';
 export const NETDISK_TIANYI_SOURCE = 'netdisk-tianyi';
 export const NETDISK_123_SOURCE = 'netdisk-123';
+export const NETDISK_UC_SOURCE = 'netdisk-uc';

-export type NetdiskProvider = 'quark' | 'mobile' | 'baidu' | 'tianyi' | '123';
+export type NetdiskProvider = 'quark' | 'mobile' | 'baidu' | 'tianyi' | '123' | 'uc';

 export function normalizeNetdiskSource(source?: string | null): string {
  if (!source) return '';
@@ -15,7 +16,7 @@ export function normalizeNetdiskSource(source?: string | null): string {

 export function isNetdiskSource(source?: string | null): boolean {
  const normalized = normalizeNetdiskSource(source);
-  return normalized === NETDISK_QUARK_SOURCE || normalized === NETDISK_MOBILE_SOURCE || normalized === NETDISK_BAIDU_SOURCE || normalized === NETDISK_TIANYI_SOURCE || normalized === NETDISK_123_SOURCE;
+  return normalized === NETDISK_QUARK_SOURCE || normalized === NETDISK_MOBILE_SOURCE || normalized === NETDISK_BAIDU_SOURCE || normalized === NETDISK_TIANYI_SOURCE || normalized === NETDISK_123_SOURCE || normalized === NETDISK_UC_SOURCE;
 }

 export function getNetdiskProvider(source?: string | null): NetdiskProvider | null {
@@ -25,6 +26,7 @@ export function getNetdiskProvider(source?: string | null): NetdiskProvider | nu
  if (normalized === NETDISK_BAIDU_SOURCE) return 'baidu';
  if (normalized === NETDISK_TIANYI_SOURCE) return 'tianyi';
  if (normalized === NETDISK_123_SOURCE) return '123';
+  if (normalized === NETDISK_UC_SOURCE) return 'uc';
  return null;
 }

@@ -47,3 +49,7 @@ export function isNetdiskTianyiSource(source?: string | null): boolean {
 export function isNetdisk123Source(source?: string | null): boolean {
  return normalizeNetdiskSource(source) === NETDISK_123_SOURCE;
 }
+
+export function isNetdiskUCSource(source?: string | null): boolean {
+  return normalizeNetdiskSource(source) === NETDISK_UC_SOURCE;
+}
@@ -0,0 +1,102 @@
+import { base58Decode, base58Encode } from '@/lib/utils';
+
+export interface UCNetdiskSessionFile {
+  fid: string;
+  name: string;
+  size?: number;
+  shareFidToken?: string;
+  pdirFid?: string;
+}
+
+export interface UCNetdiskSession {
+  id: string;
+  provider: 'uc';
+  title: string;
+  shareUrl: string;
+  passcode?: string;
+  shareId: string;
+  shareToken: string;
+  files: UCNetdiskSessionFile[];
+  savedFileIds: Record<string, string>;
+  playFolderFid?: string;
+  playFolderPath?: string;
+  createdAt: number;
+  expiresAt: number;
+}
+
+const TTL_MS = 30 * 60 * 1000;
+const sessionStore = new Map<string, UCNetdiskSession>();
+
+export function buildUCNetdiskId(input: { shareUrl: string; passcode?: string }) {
+  return base58Encode(JSON.stringify({ shareUrl: input.shareUrl, passcode: input.passcode || '' }));
+}
+
+export function parseUCNetdiskId(id: string): { shareUrl: string; passcode?: string } {
+  try {
+    const decoded = base58Decode(id);
+    const parsed = JSON.parse(decoded);
+    if (!parsed?.shareUrl || typeof parsed.shareUrl !== 'string') {
+      throw new Error('invalid uc netdisk id');
+    }
+    return {
+      shareUrl: parsed.shareUrl,
+      passcode: typeof parsed.passcode === 'string' ? parsed.passcode : '',
+    };
+  } catch {
+    throw new Error('无效的UC网盘播放 ID');
+  }
+}
+
+function pruneExpiredSessions() {
+  const now = Date.now();
+  for (const [key, value] of Array.from(sessionStore.entries())) {
+    if (value.expiresAt <= now) sessionStore.delete(key);
+  }
+}
+
+export function createUCNetdiskSession(input: {
+  title: string;
+  shareUrl: string;
+  passcode?: string;
+  shareId: string;
+  shareToken: string;
+  files: UCNetdiskSessionFile[];
+}): UCNetdiskSession {
+  pruneExpiredSessions();
+  const now = Date.now();
+  const id = buildUCNetdiskId({ shareUrl: input.shareUrl, passcode: input.passcode });
+  const session: UCNetdiskSession = {
+    id,
+    provider: 'uc',
+    title: input.title,
+    shareUrl: input.shareUrl,
+    passcode: input.passcode,
+    shareId: input.shareId,
+    shareToken: input.shareToken,
+    files: input.files,
+    savedFileIds: {},
+    createdAt: now,
+    expiresAt: now + TTL_MS,
+  };
+  sessionStore.set(id, session);
+  return session;
+}
+
+export function getUCNetdiskSession(id: string): UCNetdiskSession | null {
+  pruneExpiredSessions();
+  const session = sessionStore.get(id);
+  if (!session) return null;
+  if (session.expiresAt <= Date.now()) {
+    sessionStore.delete(id);
+    return null;
+  }
+  return session;
+}
+
+export function refreshUCNetdiskSession(id: string): UCNetdiskSession | null {
+  const session = getUCNetdiskSession(id);
+  if (!session) return null;
+  session.expiresAt = Date.now() + TTL_MS;
+  sessionStore.set(id, session);
+  return session;
+}
@@ -0,0 +1,42 @@
+import { getConfig } from '@/lib/config';
+
+import { listUCShareVideos } from './uc.client';
+import {
+  createUCNetdiskSession,
+  getUCNetdiskSession,
+  parseUCNetdiskId,
+  refreshUCNetdiskSession,
+} from './uc-session-cache';
+
+export async function resolveUCSession(id: string) {
+  const config = await getConfig();
+  const ucConfig = config.NetDiskConfig?.UC;
+  if (!ucConfig?.Enabled || !ucConfig.Cookie) {
+    throw new Error('UC网盘未配置或未启用');
+  }
+
+  let session = refreshUCNetdiskSession(id) || getUCNetdiskSession(id);
+  if (!session) {
+    const payload = parseUCNetdiskId(id);
+    const result = await listUCShareVideos(payload.shareUrl, ucConfig.Cookie, payload.passcode || '');
+    session = createUCNetdiskSession({
+      title: result.title,
+      shareUrl: payload.shareUrl,
+      passcode: payload.passcode,
+      shareId: result.shareId,
+      shareToken: result.shareToken,
+      files: result.files,
+    });
+  }
+
+  if (!session) {
+    throw new Error('UC网盘播放信息恢复失败');
+  }
+
+  return {
+    session,
+    cookie: ucConfig.Cookie,
+    token: ucConfig.Token || '',
+    savePath: ucConfig.SavePath || '/',
+  };
+}
@@ -0,0 +1,567 @@
+/* eslint-disable @typescript-eslint/no-explicit-any */
+
+import crypto from 'node:crypto';
+
+const UC_SHARE_API_BASE = 'https://pc-api.uc.cn/1/clouddrive';
+const UC_DRIVE_API_BASE = 'https://pc-api.uc.cn/1/clouddrive';
+const UC_OPEN_API_BASE = 'https://open-api-drive.uc.cn';
+const UC_QUERY_TEMPLATE = 'pr=UCBrowser&fr=pc&sys=darwin&ve=1.8.6&ut={ut}';
+const UC_OPEN_API_CLIENT_ID = '5acf882d27b74502b7040b0c65519aa7';
+const UC_OPEN_API_SIGN_KEY = 'l3srvtd7p42l0d0x1u8d7yc8ye9kki4d';
+const UC_OPEN_API_APP_VER = '1.6.8';
+const UC_OPEN_API_CHANNEL = 'UCTVOFFICIALWEB';
+
+export interface UCShareLinkInfo {
+  pwdId: string;
+  passcode: string;
+}
+
+export interface UCShareItem {
+  fid: string;
+  fileName: string;
+  dir: boolean;
+  shareFidToken?: string;
+  pdirFid?: string;
+  size?: number;
+}
+
+export interface UCShareVideoListResult {
+  title: string;
+  shareId: string;
+  shareToken: string;
+  files: Array<{
+    fid: string;
+    name: string;
+    size?: number;
+    shareFidToken?: string;
+    pdirFid?: string;
+  }>;
+}
+
+const VIDEO_EXTENSIONS = [
+  '.mp4', '.mkv', '.avi', '.m3u8', '.flv', '.ts', '.mov', '.wmv', '.webm', '.rmvb', '.rm', '.mpg', '.mpeg', '.3gp', '.f4v', '.m4v', '.vob',
+];
+
+const utCache = new Map<string, string>();
+
+function buildApiUrl(base: string, path: string, ut: string, query = '') {
+  const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+  const queryPrefix = ut
+    ? UC_QUERY_TEMPLATE.replace('{ut}', encodeURIComponent(ut))
+    : 'pr=UCBrowser&fr=pc&sys=darwin&ve=1.8.6';
+  return `${base}${normalizedPath}?${queryPrefix}${query ? `&${query}` : ''}`;
+}
+
+function getHeaders(cookie: string): HeadersInit {
+  return {
+    'content-type': 'application/json',
+    cookie,
+    referer: 'https://drive.uc.cn',
+    'user-agent':
+      'Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) uc-cloud-drive/2.5.20 Chrome/100.0.4896.160 Electron/18.3.5.4-b478491100 Safari/537.36 Channel/pckk_other_ch',
+  };
+}
+
+export function getUCPlayHeaders(cookie: string): Record<string, string> {
+  const keepKeys = ['_UP_A4A_11_', 'tfstk', '__uid', '__pus', '__kp', '__puus'];
+  const filteredCookie = cookie
+    .split(';')
+    .map((item) => item.trim())
+    .filter((item) => keepKeys.some((key) => item.includes(key)))
+    .join('; ');
+
+  return {
+    cookie: filteredCookie,
+    referer: 'https://drive.uc.cn/',
+    'user-agent':
+      'Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) uc-cloud-drive/1.8.6 Chrome/100.0.4896.160 Electron/18.3.5.16-b62cf9c50d Safari/537.36 Channel/ucpan_other_ch',
+  };
+}
+
+export function normalizeUCCookie(cookie: string): string {
+  return cookie
+    .replace(/；/g, ';')
+    .replace(/：/g, ':')
+    .replace(/，/g, ',')
+    .trim();
+}
+
+export function assertUCCookieHeaderSafe(cookie: string): string {
+  const normalized = normalizeUCCookie(cookie);
+  for (let i = 0; i < normalized.length; i += 1) {
+    if (normalized.charCodeAt(i) > 255) {
+      throw new Error('UC Cookie 含有非法字符，请确认没有中文标点、中文空格或说明文字');
+    }
+  }
+  return normalized;
+}
+
+function normalizePath(path: string): string {
+  const trimmed = path.trim();
+  if (!trimmed || trimmed === '/') return '/';
+  return `/${trimmed.replace(/^\/+|\/+$/g, '')}`;
+}
+
+function joinPath(...parts: string[]) {
+  const joined = parts.filter(Boolean).join('/').replace(/\/+/g, '/');
+  return normalizePath(joined);
+}
+
+function sanitizeFolderName(name: string) {
+  return (name || 'uc-temp')
+    .replace(/[<>:"/\\|?*]/g, ' ')
+    .replace(/[\r\n\t]/g, ' ')
+    .replace(/\s+/g, ' ')
+    .trim()
+    .slice(0, 80);
+}
+
+async function parseJson(response: Response) {
+  const text = await response.text();
+  try {
+    return JSON.parse(text);
+  } catch {
+    throw new Error(`UC 接口返回异常：${text.slice(0, 200)}`);
+  }
+}
+
+function ensureOk(data: any, fallbackMessage: string) {
+  if (data?.code === 0 || data?.code === 200 || data?.status === 200) return;
+  throw new Error(data?.message || data?.msg || fallbackMessage);
+}
+
+async function resolveUCUt(cookie: string) {
+  const safeCookie = assertUCCookieHeaderSafe(cookie);
+  const cached = utCache.get(safeCookie);
+  if (cached) return cached;
+
+  const tryFetchUt = async (headers?: HeadersInit) => {
+    const response = await fetch(`${UC_DRIVE_API_BASE}/file`, {
+      method: 'GET',
+      headers,
+      cache: 'no-store',
+    });
+    const text = (await response.text()).trim();
+    if (!response.ok || !text) return '';
+    return text;
+  };
+
+  let ut = await tryFetchUt();
+  if (!ut) {
+    ut = await tryFetchUt(getHeaders(safeCookie));
+  }
+
+  if (!ut) {
+    utCache.set(safeCookie, '');
+    return '';
+  }
+
+  utCache.set(safeCookie, ut);
+  return ut;
+}
+
+function getDriveItemName(item: any): string {
+  return String(item?.file_name || item?.name || '');
+}
+
+function buildInstantPlayFolderName(pwdId: string, title?: string) {
+  const baseName = sanitizeFolderName(title || 'uc-temp') || 'uc-temp';
+  return `${baseName}_${pwdId}`.slice(0, 120);
+}
+
+export function parseUCShareUrl(url: string, passcode = ''): UCShareLinkInfo {
+  const parsed = new URL(url);
+  const pwdId = parsed.pathname.match(/\/s\/([A-Za-z0-9_-]+)/)?.[1] || '';
+  if (!pwdId) {
+    throw new Error('无法解析 UC 分享链接');
+  }
+  return {
+    pwdId,
+    passcode: passcode || parsed.searchParams.get('pwd') || parsed.searchParams.get('passcode') || '',
+  };
+}
+
+async function fetchShareToken(cookie: string, share: UCShareLinkInfo, ut: string) {
+  const response = await fetch(buildApiUrl(UC_SHARE_API_BASE, '/share/sharepage/token', ut), {
+    method: 'POST',
+    headers: getHeaders(cookie),
+    body: JSON.stringify({
+      pwd_id: share.pwdId,
+      passcode: share.passcode,
+    }),
+    cache: 'no-store',
+  });
+
+  const data = await parseJson(response);
+  ensureOk(data, '获取 UC 分享 token 失败');
+  const stoken = data?.data?.stoken || data?.data?.share_token || data?.data?.token;
+  if (!stoken) {
+    throw new Error('UC 分享 token 缺失');
+  }
+  return {
+    stoken,
+    shareTitle: data?.data?.title || '',
+  };
+}
+
+async function fetchShareFolderItems(cookie: string, pwdId: string, stoken: string, ut: string, pdirFid = '0', page = 1): Promise<{ items: UCShareItem[]; total?: number }> {
+  const query = new URLSearchParams({
+    pwd_id: pwdId,
+    stoken,
+    pdir_fid: pdirFid,
+    force: '0',
+    _page: String(page),
+    _size: '100',
+    _sort: 'file_type:asc,file_name:asc',
+  });
+  const response = await fetch(buildApiUrl(UC_SHARE_API_BASE, '/share/sharepage/detail', ut, query.toString()), {
+    method: 'GET',
+    headers: getHeaders(cookie),
+    cache: 'no-store',
+  });
+
+  const data = await parseJson(response);
+  ensureOk(data, '获取 UC 分享详情失败');
+  const list = data?.data?.list || [];
+  return {
+    items: list.map((item: any) => ({
+      fid: String(item.fid || item.file_id || ''),
+      fileName: String(item.file_name || item.name || ''),
+      dir: Boolean(item.dir || item.is_dir || item.file_type === 0),
+      shareFidToken: item.share_fid_token || item.fid_token || item.share_token || undefined,
+      pdirFid: String(item.pdir_fid || pdirFid || '0'),
+      size: Number(item.size || 0),
+    })),
+    total: Number(data?.metadata?._total || 0),
+  };
+}
+
+async function collectShareItemsRecursive(cookie: string, pwdId: string, stoken: string, ut: string, pdirFid = '0'): Promise<UCShareItem[]> {
+  const result: UCShareItem[] = [];
+  const pageSize = 100;
+  for (let page = 1; page < 100; page += 1) {
+    const { items, total } = await fetchShareFolderItems(cookie, pwdId, stoken, ut, pdirFid, page);
+    for (const item of items) {
+      if (item.dir) {
+        const children = await collectShareItemsRecursive(cookie, pwdId, stoken, ut, item.fid);
+        result.push(...children);
+      } else {
+        result.push(item);
+      }
+    }
+    if (items.length < pageSize || page >= Math.ceil((total || 0) / pageSize)) break;
+  }
+  return result;
+}
+
+function isVideoFile(fileName: string) {
+  const lower = fileName.toLowerCase();
+  return VIDEO_EXTENSIONS.some((ext) => lower.endsWith(ext));
+}
+
+async function fetchDriveFolderItems(cookie: string, ut: string, pdirFid = '0', page = 1, size = 200): Promise<any[]> {
+  const query = new URLSearchParams({
+    pdir_fid: pdirFid,
+    _page: String(page),
+    _size: String(size),
+    _sort: 'file_type:asc,file_name:asc',
+  });
+  const response = await fetch(buildApiUrl(UC_DRIVE_API_BASE, '/file/sort', ut, query.toString()), {
+    method: 'GET',
+    headers: getHeaders(cookie),
+    cache: 'no-store',
+  });
+  const data = await parseJson(response);
+  ensureOk(data, '获取 UC 目录列表失败');
+  return data?.data?.list || [];
+}
+
+async function fetchAllDriveFolderItems(cookie: string, ut: string, pdirFid = '0'): Promise<any[]> {
+  const allItems: any[] = [];
+  const pageSize = 200;
+  for (let page = 1; page < 100; page += 1) {
+    const items = await fetchDriveFolderItems(cookie, ut, pdirFid, page, pageSize);
+    allItems.push(...items);
+    if (items.length < pageSize) break;
+  }
+  return allItems;
+}
+
+async function createDriveFolder(cookie: string, ut: string, parentFid: string, folderName: string) {
+  const response = await fetch(buildApiUrl(UC_DRIVE_API_BASE, '/file', ut), {
+    method: 'POST',
+    headers: getHeaders(cookie),
+    body: JSON.stringify({
+      pdir_fid: parentFid,
+      file_name: folderName,
+      dir_path: '',
+      dir_init_lock: false,
+    }),
+    cache: 'no-store',
+  });
+  const data = await parseJson(response);
+  ensureOk(data, `创建 UC 目录失败：${folderName}`);
+  const fid = data?.data?.fid || data?.data?.file_id || data?.metadata?.fid;
+  if (!fid) throw new Error(`UC 目录创建成功但未返回 fid：${folderName}`);
+  return String(fid);
+}
+
+async function findDirectoryByName(cookie: string, ut: string, parentFid: string, folderName: string): Promise<any | null> {
+  const items = await fetchAllDriveFolderItems(cookie, ut, parentFid);
+  return items.find((item: any) => Boolean(item.dir || item.is_dir) && getDriveItemName(item) === folderName) || null;
+}
+
+export async function validateUCCookieReadable(cookie: string): Promise<void> {
+  const safeCookie = assertUCCookieHeaderSafe(cookie);
+  const ut = await resolveUCUt(safeCookie);
+  await fetchDriveFolderItems(safeCookie, ut, '0');
+}
+
+export async function listUCShareVideos(shareUrl: string, cookie: string, passcode = ''): Promise<UCShareVideoListResult> {
+  const safeCookie = assertUCCookieHeaderSafe(cookie);
+  const ut = await resolveUCUt(safeCookie);
+  const share = parseUCShareUrl(shareUrl, passcode);
+  const { stoken, shareTitle } = await fetchShareToken(safeCookie, share, ut);
+  const allItems = await collectShareItemsRecursive(safeCookie, share.pwdId, stoken, ut, '0');
+  const files = allItems
+    .filter((item) => !item.dir && isVideoFile(item.fileName) && Number(item.size || 0) >= 5 * 1024 * 1024)
+    .map((item) => ({
+      fid: item.fid,
+      name: item.fileName,
+      size: item.size,
+      shareFidToken: item.shareFidToken,
+      pdirFid: item.pdirFid,
+    }));
+  if (files.length === 0) throw new Error('分享中没有可播放的视频文件');
+  return {
+    title: shareTitle || 'UC网盘立即播放',
+    shareId: share.pwdId,
+    shareToken: stoken,
+    files,
+  };
+}
+
+export async function ensureUCDrivePath(cookie: string, inputPath: string): Promise<{ fid: string; path: string }> {
+  const safeCookie = assertUCCookieHeaderSafe(cookie);
+  const ut = await resolveUCUt(safeCookie);
+  const normalized = normalizePath(inputPath);
+  if (normalized === '/') return { fid: '0', path: normalized };
+
+  const segments = normalized.split('/').filter(Boolean);
+  let currentFid = '0';
+  let currentPath = '';
+  for (const segment of segments) {
+    const items = await fetchDriveFolderItems(safeCookie, ut, currentFid);
+    const existed = items.find((item: any) => Boolean(item.dir || item.is_dir) && getDriveItemName(item) === segment);
+    currentPath = joinPath(currentPath, segment);
+    if (existed) {
+      currentFid = String(existed.fid || existed.file_id);
+      continue;
+    }
+    currentFid = await createDriveFolder(safeCookie, ut, currentFid, segment);
+  }
+  return { fid: currentFid, path: currentPath || '/' };
+}
+
+async function submitSaveTask(cookie: string, ut: string, share: UCShareLinkInfo, stoken: string, toPdirFid: string, items: UCShareItem[]) {
+  if (items.length === 0) throw new Error('没有可保存的文件');
+  const response = await fetch(buildApiUrl(UC_SHARE_API_BASE, '/share/sharepage/save', ut), {
+    method: 'POST',
+    headers: getHeaders(cookie),
+    body: JSON.stringify({
+      pwd_id: share.pwdId,
+      stoken,
+      pdir_fid: '0',
+      to_pdir_fid: toPdirFid,
+      scene: 'link',
+      filelist: items.map((item) => item.fid),
+      fid_list: items.map((item) => item.fid),
+      fid_token_list: items.map((item) => item.shareFidToken || ''),
+      share_fid_token_list: items.map((item) => item.shareFidToken || ''),
+    }),
+    cache: 'no-store',
+  });
+  const data = await parseJson(response);
+  ensureOk(data, '提交 UC 转存任务失败');
+  return data?.data?.task_id ? String(data.data.task_id) : undefined;
+}
+
+async function _pollTask(cookie: string, ut: string, taskId: string) {
+  for (let i = 0; i < 25; i += 1) {
+    const query = new URLSearchParams({ task_id: taskId, retry_index: String(i) });
+    const response = await fetch(buildApiUrl(UC_SHARE_API_BASE, '/task', ut, query.toString()), {
+      method: 'GET', headers: getHeaders(cookie), cache: 'no-store',
+    });
+    const data = await parseJson(response);
+    ensureOk(data, '查询 UC 任务状态失败');
+    const task = data?.data || {};
+    if (task?.status === 2 || task?.status === 'finished' || task?.status === 'success' || task?.finished_at) return;
+    if (task?.status === -1 || task?.status === 'failed' || task?.err_code) {
+      throw new Error(task?.message || task?.err_msg || 'UC 任务执行失败');
+    }
+    await new Promise((resolve) => setTimeout(resolve, 1200));
+  }
+  throw new Error('UC 任务处理超时');
+}
+
+export async function ensureUCPlayFolder(cookie: string, playTempSavePath: string, shareId: string, title?: string): Promise<{ folderFid: string; folderPath: string; folderName: string }> {
+  const safeCookie = assertUCCookieHeaderSafe(cookie);
+  const ut = await resolveUCUt(safeCookie);
+  const tempRoot = await ensureUCDrivePath(safeCookie, playTempSavePath);
+  const folderName = buildInstantPlayFolderName(shareId, title);
+  const existedFolder = await findDirectoryByName(safeCookie, ut, tempRoot.fid, folderName);
+  if (existedFolder) {
+    return {
+      folderFid: String(existedFolder.fid || existedFolder.file_id),
+      folderPath: joinPath(tempRoot.path, folderName),
+      folderName,
+    };
+  }
+  const folderFid = await createDriveFolder(safeCookie, ut, tempRoot.fid, folderName);
+  return { folderFid, folderPath: joinPath(tempRoot.path, folderName), folderName };
+}
+
+export async function saveUCShareFile(cookie: string, input: { shareId: string; shareToken: string; fileId: string; shareFileToken?: string; playFolderFid: string; }): Promise<string> {
+  const safeCookie = assertUCCookieHeaderSafe(cookie);
+  const ut = await resolveUCUt(safeCookie);
+  const taskId = await submitSaveTask(safeCookie, ut, { pwdId: input.shareId, passcode: '' }, input.shareToken, input.playFolderFid, [{ fid: input.fileId, fileName: '', dir: false, shareFidToken: input.shareFileToken }]);
+  if (!taskId) throw new Error('UC 转存任务创建失败');
+
+  for (let i = 0; i < 25; i += 1) {
+    const query = new URLSearchParams({ task_id: taskId, retry_index: String(i) });
+    const response = await fetch(buildApiUrl(UC_SHARE_API_BASE, '/task', ut, query.toString()), { method: 'GET', headers: getHeaders(safeCookie), cache: 'no-store' });
+    const data = await parseJson(response);
+    ensureOk(data, '查询 UC 任务状态失败');
+    const saveAsTopFids = data?.data?.save_as?.save_as_top_fids;
+    if (Array.isArray(saveAsTopFids) && saveAsTopFids.length > 0) {
+      return String(saveAsTopFids[0]);
+    }
+    const status = data?.data?.status;
+    if (status === -1 || status === 'failed' || data?.data?.err_code) {
+      throw new Error(data?.data?.message || data?.data?.err_msg || 'UC 任务执行失败');
+    }
+    if (status === 2 || status === 'finished' || status === 'success' || data?.data?.finished_at) break;
+    await new Promise((resolve) => setTimeout(resolve, 1200));
+  }
+  throw new Error('UC 转存结果获取失败');
+}
+
+function generateDeviceID(timestamp: string) {
+  return crypto.createHash('md5').update(timestamp).digest('hex').slice(0, 16);
+}
+
+function generateReqId(deviceID: string, timestamp: string) {
+  return crypto.createHash('md5').update(deviceID + timestamp).digest('hex').slice(0, 16);
+}
+
+function generateXPanToken(method: string, pathname: string, timestamp: string, key: string) {
+  return crypto.createHash('sha256').update(`${method}&${pathname}&${timestamp}&${key}`).digest('hex');
+}
+
+export async function getUCPlayUrls(cookie: string, savedFileId: string, token = ''): Promise<Array<{ name: string; url: string; priority: number; headers?: Record<string, string> }>> {
+  const safeCookie = assertUCCookieHeaderSafe(cookie);
+  const ut = await resolveUCUt(safeCookie);
+  const urls: Array<{ name: string; url: string; priority: number; headers?: Record<string, string> }> = [];
+
+  if (token) {
+    try {
+      const pathname = '/file';
+      const timestamp = `${Math.floor(Date.now() / 1000)}000`;
+      const deviceId = generateDeviceID(timestamp);
+      const reqId = generateReqId(deviceId, timestamp);
+      const xPanToken = generateXPanToken('GET', pathname, timestamp, UC_OPEN_API_SIGN_KEY);
+      const query = new URLSearchParams({
+        req_id: reqId,
+        access_token: token,
+        app_ver: UC_OPEN_API_APP_VER,
+        device_id: deviceId,
+        device_brand: 'Xiaomi',
+        platform: 'tv',
+        device_name: 'M2004J7AC',
+        device_model: 'M2004J7AC',
+        build_device: 'M2004J7AC',
+        build_product: 'M2004J7AC',
+        device_gpu: 'Adreno (TM) 550',
+        activity_rect: '{}',
+        channel: UC_OPEN_API_CHANNEL,
+        method: 'streaming',
+        group_by: 'source',
+        fid: savedFileId,
+        resolution: 'low,normal,high,super,2k,4k',
+        support: 'dolby_vision',
+      });
+      const response = await fetch(`${UC_OPEN_API_BASE}${pathname}?${query.toString()}`, {
+        method: 'GET',
+        headers: {
+          'user-agent': 'Mozilla/5.0 (Linux; Android 9) AppleWebKit/533.1 (KHTML, like Gecko) Mobile Safari/533.1',
+          connection: 'Keep-Alive',
+          'accept-encoding': 'gzip',
+          'x-pan-tm': timestamp,
+          'x-pan-token': xPanToken,
+          'content-type': 'text/plain;charset=UTF-8',
+          'x-pan-client-id': UC_OPEN_API_CLIENT_ID,
+        },
+        cache: 'no-store',
+      });
+      const data = await parseJson(response);
+      const openVideoInfo = Array.isArray(data?.data?.video_info)
+        ? data.data.video_info.find((item: any) => item?.accessable && item?.url)
+        : null;
+      if (openVideoInfo?.url) {
+        urls.push({ name: '原画', url: String(openVideoInfo.url), priority: 9999, headers: {} });
+      }
+    } catch {
+      // ignore token failure, fallback to cookie mode
+    }
+  }
+
+  try {
+    const response = await fetch(buildApiUrl(UC_DRIVE_API_BASE, '/file/download', ut), {
+      method: 'POST',
+      headers: getHeaders(safeCookie),
+      body: JSON.stringify({ fids: [savedFileId] }),
+      cache: 'no-store',
+    });
+    const data = await parseJson(response);
+    ensureOk(data, '获取 UC 下载地址失败');
+    const downloadUrl = data?.data?.[0]?.download_url;
+    if (downloadUrl) {
+      urls.push({ name: '原画', url: String(downloadUrl), priority: 9999, headers: getUCPlayHeaders(safeCookie) });
+    }
+  } catch {
+    // ignore
+  }
+
+  try {
+    const response = await fetch(buildApiUrl(UC_DRIVE_API_BASE, '/file/v2/play', ut), {
+      method: 'POST',
+      headers: getHeaders(safeCookie),
+      body: JSON.stringify({
+        fid: savedFileId,
+        resolutions: 'normal,low,high,super,2k,4k',
+        supports: 'fmp4',
+      }),
+      cache: 'no-store',
+    });
+    const data = await parseJson(response);
+    ensureOk(data, '获取 UC 转码地址失败');
+    const nameMap: Record<string, string> = { FOUR_K: '4K', SUPER: '超清', HIGH: '高清', NORMAL: '流畅', LOW: '低清' };
+    if (Array.isArray(data?.data?.video_list)) {
+      for (const video of data.data.video_list) {
+        const resolution = video?.video_info?.resoultion;
+        const playUrl = video?.video_info?.url;
+        const priority = Number(video?.video_info?.width || 0);
+        if (resolution && playUrl) {
+          urls.push({ name: nameMap[String(resolution)] || String(resolution), url: String(playUrl), priority, headers: getUCPlayHeaders(safeCookie) });
+        }
+      }
+    }
+  } catch {
+    // ignore
+  }
+
+  const deduped = urls.filter((item, index, array) => array.findIndex((v) => v.url === item.url) === index);
+  deduped.sort((a, b) => b.priority - a.priority);
+  if (deduped.length === 0) throw new Error('未获取到 UC 播放地址');
+  return deduped;
+}