IYUU需在下载器管理中关闭 校验后做种

自行修改配置的站点限速

将代码添加进Vertex定时脚本

async () => {
    const util = require('../libs/util');

    // 站点配置
    const SITE_CONFIG = {
        // 普通限速
        normalLimit: {
            speed: 90 * 1024 * 1024, // 90M/s
            description: '普通限速'
        },
        // 不限速站点列表
        unlimitedSites: ['qingwa', 'ubits'],
        // 特殊限速站点配置
        specialSites: [
            {
                keyword: 'carpt',
                speed: 29 * 1024 * 1024, // 29M/s
                description: 'carpt站点限速'
            },
            {
                keyword: 'btschool', // 会匹配 btschool.club 等任何包含 btschool 的域名
                speed: 25 * 1024 * 1024, // 25M/s
                description: 'btschool站点限速'
            }
        ]
    };

    // 允许处理的下载器ID列表
    const allowedClientIds = ['507a7287', '1d99a25c', 'fb8ed0d3'];

    // 从URL中提取域名（使用缓存优化）
    const domainCache = new Map();
    function extractDomain(url) {
        if (domainCache.has(url)) {
            return domainCache.get(url);
        }
        try {
            let domain = url.replace(/^https?:\/\//, '').split(/[/?]/)[0];
            domainCache.set(url, domain);
            return domain;
        } catch (error) {
            return url;
        }
    }

    async function processTorrent(torrent, runningClient, client) {
        if (!torrent || torrent.category !== 'IYUU自动辅种' || torrent.progress !== 1) {
            return;
        }

        // 获取所有 tracker
        const trackers = torrent.trackers || [torrent.tracker];
        const domains = [...new Set(trackers.map(t => extractDomain(t.url || t)))].join(', ');

        // 检查是否有任何一个 tracker 匹配不限速列表
        const trackerUrls = trackers.map(t => (t.url || t).toLowerCase());
        const shouldUnlimit = SITE_CONFIG.unlimitedSites.some(site => 
            trackerUrls.some(url => url.includes(site.toLowerCase()))
        );

        let speedInfo;
        let speed;

        if (shouldUnlimit) {
            speed = -1;
            speedInfo = '不限速';
        } else {
            // 检查是否匹配特殊限速
            const matchedSite = SITE_CONFIG.specialSites.find(site => 
                trackerUrls.some(url => url.includes(site.keyword.toLowerCase()))
            );

            if (matchedSite) {
                speed = matchedSite.speed;
                speedInfo = `${matchedSite.speed/(1024*1024)}M/s`;
            } else {
                speed = SITE_CONFIG.normalLimit.speed;
                speedInfo = `${SITE_CONFIG.normalLimit.speed/(1024*1024)}M/s`;
            }
        }

        // 批量执行操作
        await Promise.all([
            runningClient.resumeTorrent(torrent.hash),
            runningClient.setSpeedLimit(torrent.hash, 'upload', speed)
        ]);

        // 输出简洁的日志
        logger.sc(`[${client.alias}] ${domains} | ${speedInfo} | ${torrent.name}`);
    }

    async function resumeAllTorrents() {
        const QB_CLIENTS = util.listClient();
        const filteredClients = QB_CLIENTS.filter(client => allowedClientIds.includes(client.id));

        await Promise.all(filteredClients.map(async (client) => {
            const clientId = client.id;
            const runningClient = global.runningClient[clientId];
            if (!runningClient?.status) {
                return;
            }

            const torrents = runningClient.maindata.torrents;
            if (!torrents?.length) {
                return;
            }

            // 并行处理所有种子
            await Promise.all(torrents.map(torrent => 
                processTorrent(torrent, runningClient, client)
            ));
        }));
    }

    try {
        await resumeAllTorrents();
    } catch (error) {
        logger.sc("执行过程中出错:", error);
    }
};