koishi-plugin-kkk 1.0.0

package/lib/karin/module/utils/Network/ImageDownloader.js

@@ -0,0 +1,250 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ImageDownloader = void 0;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_path_1 = __importDefault(require("node:path"));
+const node_karin_1 = require("../../../../compat/node-karin.js");
+const Config_1 = require("../Config");
+const helpers_1 = require("./helpers");
+/**
+ * 图片下载管理器
+ * 根据配置决定是否本地下载图片，并管理临时文件的生命周期
+ */
+class ImageDownloader {
+    axiosInstance;
+    tempDir;
+    maxRetries = 3;
+    retryDelay = 1000; // 初始重试延迟（毫秒）
+    /**
+     * 创建图片下载管理器实例
+     * @param axiosInstance - Axios 实例
+     * @param tempDir - 临时文件目录
+     */
+    constructor(axiosInstance, tempDir) {
+        this.axiosInstance = axiosInstance;
+        this.tempDir = tempDir;
+        // 确保临时目录存在
+        if (!node_fs_1.default.existsSync(this.tempDir)) {
+            node_fs_1.default.mkdirSync(this.tempDir, { recursive: true });
+        }
+    }
+    /**
+     * 处理图片 URL，根据配置决定返回格式
+     * @param imageUrl - 图片 URL
+     * @param title - 作品标题（用于文件命名）
+     * @param index - 图片索引（用于多图场景）
+     * @returns 处理后的图片路径（HTTP URL / file:// 协议 / base64://）
+     */
+    async processImage(imageUrl, title, index) {
+        if (!/^https?:\/\//i.test(imageUrl)) {
+            return imageUrl;
+        }
+        const mode = Config_1.Config.app.imageSendMode;
+        switch (mode) {
+            case 'base64':
+                // base64 模式：下载并转换为 base64
+                try {
+                    return await this.downloadAndConvertToBase64(imageUrl);
+                }
+                catch (error) {
+                    node_karin_1.logger.error(`图片转换 base64 失败，回退到原始 URL: ${imageUrl}`, error);
+                    return imageUrl;
+                }
+            case 'file':
+                // file 协议模式：下载到本地并返回 file:// 协议
+                try {
+                    const result = await this.downloadImage(imageUrl, title, index);
+                    // 如果需要自动删除，设置延迟删除任务
+                    if (result.shouldDelete) {
+                        this.scheduleDelete(result.filePath);
+                    }
+                    return result.filePath;
+                }
+                catch (error) {
+                    node_karin_1.logger.error(`图片下载失败，回退到原始 URL: ${imageUrl}`, error);
+                    return imageUrl;
+                }
+            case 'url':
+            default:
+                // URL 模式：直接返回原始 HTTP URL
+                return imageUrl;
+        }
+    }
+    /**
+     * 下载图片并转换为 base64
+     * @param imageUrl - 图片 URL
+     * @returns base64 格式的图片数据
+     */
+    async downloadAndConvertToBase64(imageUrl) {
+        // 生成临时文件名
+        const filename = this.generateFilename(imageUrl);
+        const filePath = node_path_1.default.join(this.tempDir, filename);
+        try {
+            // 下载图片到本地（带重试）
+            const response = await this.downloadWithRetry(imageUrl);
+            // 保存到本地
+            node_fs_1.default.writeFileSync(filePath, response.data);
+            // 从本地文件读取并转换为 base64
+            const fileBuffer = node_fs_1.default.readFileSync(filePath);
+            const base64 = fileBuffer.toString('base64');
+            node_karin_1.logger.debug(`图片已下载并转换为 base64: ${imageUrl.substring(0, 50)}...`);
+            return `base64://${base64}`;
+        }
+        finally {
+            // 如果配置了自动删除缓存，立即删除临时文件
+            if (Config_1.Config.app.removeCache && node_fs_1.default.existsSync(filePath)) {
+                try {
+                    node_fs_1.default.unlinkSync(filePath);
+                    node_karin_1.logger.debug(`临时文件已删除: ${filePath}`);
+                }
+                catch (error) {
+                    node_karin_1.logger.error(`删除临时文件失败: ${filePath}`, error);
+                }
+            }
+        }
+    }
+    /**
+     * 下载图片到本地
+     * @param imageUrl - 图片 URL
+     * @param title - 作品标题
+     * @param index - 图片索引
+     * @returns 下载结果
+     */
+    async downloadImage(imageUrl, title, index) {
+        // 生成文件名
+        const filename = this.generateFilename(imageUrl, title, index);
+        const filePath = node_path_1.default.join(this.tempDir, filename);
+        // 下载图片（带重试）
+        const response = await this.downloadWithRetry(imageUrl);
+        // 保存到本地
+        node_fs_1.default.writeFileSync(filePath, response.data);
+        node_karin_1.logger.debug(`图片已下载: ${filePath}`);
+        return {
+            filePath: `file://${filePath}`,
+            shouldDelete: true
+        };
+    }
+    /**
+     * 带重试机制的图片下载
+     * @param imageUrl - 图片 URL
+     * @param retryCount - 当前重试次数
+     * @returns Axios 响应
+     */
+    async downloadWithRetry(imageUrl, retryCount = 0) {
+        try {
+            const response = await this.axiosInstance.get(imageUrl, {
+                responseType: 'arraybuffer',
+                timeout: 30000
+            });
+            if (retryCount > 0) {
+                node_karin_1.logger.info(`图片下载成功（重试 ${retryCount} 次后）: ${imageUrl.substring(0, 50)}...`);
+            }
+            return response;
+        }
+        catch (error) {
+            if (retryCount < this.maxRetries) {
+                const delay = this.retryDelay * Math.pow(2, retryCount); // 指数退避
+                node_karin_1.logger.warn(`图片下载失败，${delay}ms 后进行第 ${retryCount + 1}/${this.maxRetries} 次重试: ${imageUrl.substring(0, 50)}...`, error);
+                // 等待后重试
+                await this.sleep(delay);
+                return this.downloadWithRetry(imageUrl, retryCount + 1);
+            }
+            // 重试次数用尽，抛出错误
+            node_karin_1.logger.error(`图片下载失败，已重试 ${this.maxRetries} 次: ${imageUrl}`, error);
+            throw error;
+        }
+    }
+    /**
+     * 延迟函数
+     * @param ms - 延迟毫秒数
+     */
+    sleep(ms) {
+        return new Promise((resolve) => setTimeout(resolve, ms));
+    }
+    /**
+     * 生成文件名
+     * @param imageUrl - 图片 URL
+     * @param title - 作品标题
+     * @param index - 图片索引
+     * @returns 文件名
+     */
+    generateFilename(imageUrl, title, index) {
+        // 获取文件扩展名
+        const ext = this.getExtension(imageUrl);
+        // 根据 removeCache 配置决定文件名
+        if (Config_1.Config.app.removeCache) {
+            // 使用时间戳
+            const timestamp = Date.now();
+            const indexSuffix = index !== undefined ? `_${index}` : '';
+            return `tmp_${timestamp}${indexSuffix}${ext}`;
+        }
+        else {
+            // 使用作品标题
+            const safeTitle = title ? (0, helpers_1.sanitizeFilename)(title) : `image_${Date.now()}`;
+            const indexSuffix = index !== undefined ? `_${index}` : '';
+            return `${safeTitle}${indexSuffix}${ext}`;
+        }
+    }
+    /**
+     * 从 URL 中提取文件扩展名
+     * @param url - 图片 URL
+     * @returns 文件扩展名（包含点号）
+     */
+    getExtension(url) {
+        try {
+            const urlObj = new URL(url);
+            const pathname = urlObj.pathname;
+            const ext = node_path_1.default.extname(pathname);
+            // 如果有扩展名且是常见图片格式，使用它
+            if (ext && /^\.(jpg|jpeg|png|gif|webp|bmp)$/i.test(ext)) {
+                return ext;
+            }
+        }
+        catch {
+            // URL 解析失败，继续使用默认扩展名
+        }
+        // 默认使用 .jpg
+        return '.jpg';
+    }
+    /**
+     * 安排文件删除任务
+     * @param filePath - 文件路径（file:// 协议）
+     */
+    scheduleDelete(filePath) {
+        // 移除 file:// 协议前缀
+        const actualPath = filePath.replace(/^file:\/\//, '');
+        // 10 分钟后删除文件
+        setTimeout(() => {
+            this.deleteFile(actualPath);
+        }, 10 * 60 * 1000);
+    }
+    /**
+     * 删除文件
+     * @param filePath - 文件路径
+     */
+    deleteFile(filePath) {
+        try {
+            if (node_fs_1.default.existsSync(filePath)) {
+                node_fs_1.default.unlinkSync(filePath);
+                node_karin_1.logger.debug(`临时图片已删除: ${filePath}`);
+            }
+        }
+        catch (error) {
+            node_karin_1.logger.error(`删除临时图片失败: ${filePath}`, error);
+        }
+    }
+    /**
+     * 批量处理图片
+     * @param imageUrls - 图片 URL 数组
+     * @param title - 作品标题
+     * @returns 处理后的图片路径数组
+     */
+    async processImages(imageUrls, title) {
+        const results = await Promise.all(imageUrls.map((url, index) => this.processImage(url, title, index)));
+        return results;
+    }
+}
+exports.ImageDownloader = ImageDownloader;

package/lib/karin/module/utils/Network/Network.js

@@ -0,0 +1,332 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Network = void 0;
+const node_karin_1 = require("../../../../compat/node-karin.js");
+const axios_1 = __importStar(require("../../../../compat/axios.js"));
+const constants_1 = require("./constants");
+const Downloader_1 = require("./Downloader");
+const helpers_1 = require("./helpers");
+/**
+ * 网络请求类
+ * 支持常规请求、文件下载（带限速和断点续传）、重定向跟踪等功能
+ */
+class Network {
+    url;
+    method;
+    headers;
+    type;
+    body;
+    axiosInstance;
+    timeout;
+    filepath;
+    maxRetries;
+    throttleConfig;
+    /**
+     * 创建网络请求实例
+     *
+     * @remarks
+     * 实例会自动处理可恢复的网络错误（如连接超时、重置等），并进行指数退避重试。
+     * 默认重试 3 次，可通过 `maxRetries` 配置。
+     * 支持限速下载，避免触发服务器风控。
+     *
+     * @param data - 配置对象
+     */
+    constructor(data) {
+        this.headers = data.headers ? Object.fromEntries(Object.entries(data.headers).map(([key, value]) => [key, String(value)])) : {};
+        // 合并默认头
+        this.headers = {
+            ...Object.fromEntries(Object.entries(constants_1.BASE_HEADERS ?? {}).map(([key, value]) => [key, String(value)])),
+            ...this.headers
+        };
+        this.url = data.url ?? '';
+        this.type = data.type ?? 'json';
+        this.method = data.method ?? 'GET';
+        this.body = data.body ?? null;
+        this.timeout = data.timeout ?? 15000;
+        this.filepath = data.filepath ?? '';
+        this.maxRetries = data.maxRetries ?? 3;
+        this.throttleConfig = data.throttle;
+        // 创建 axios 实例
+        this.axiosInstance = axios_1.default.create({
+            timeout: this.timeout,
+            headers: this.headers,
+            maxRedirects: 5,
+            validateStatus: () => true
+        });
+        // 添加响应拦截器处理重试
+        this.axiosInstance.interceptors.response.use(undefined, async (error) => {
+            const config = error.config;
+            if (!config || config.skipRetry) {
+                return Promise.reject(error);
+            }
+            config.__retryCount = config.__retryCount || 0;
+            if (config.__retryCount >= this.maxRetries) {
+                return Promise.reject(error);
+            }
+            if (!(0, helpers_1.isRecoverableNetworkError)(error)) {
+                return Promise.reject(error);
+            }
+            config.__retryCount += 1;
+            const nextDelay = Math.max(1000, Math.min(2 ** (config.__retryCount - 1) * 1000, 8000));
+            node_karin_1.logger.warn(`[koishi-plugin-kkk] axios 实例请求失败，正在重试... (${config.__retryCount}/${this.maxRetries})，将在 ${nextDelay / 1000} 秒后重试`);
+            await new Promise((resolve) => setTimeout(resolve, nextDelay));
+            return this.axiosInstance(config);
+        });
+    }
+    get config() {
+        const config = {
+            url: this.url,
+            method: this.method,
+            headers: this.headers,
+            responseType: this.type
+        };
+        if (this.method === 'POST' && this.body) {
+            config.data = this.body;
+        }
+        return config;
+    }
+    /**
+     * 下载文件流
+     * 支持断点续传、限速下载、自动重试
+     *
+     * @param progressCallback 进度回调函数
+     * @param retryCount 重试次数（内部使用）
+     */
+    async downloadStream(progressCallback, retryCount = 0) {
+        const downloader = new Downloader_1.Downloader(this.axiosInstance, this.url, this.filepath, this.headers, this.timeout, this.maxRetries, this.throttleConfig);
+        return downloader.download(progressCallback, retryCount);
+    }
+    async getfetch() {
+        try {
+            return await this.returnResult();
+        }
+        catch (error) {
+            node_karin_1.logger.info(error);
+            return false;
+        }
+    }
+    async returnResult() {
+        let response = {};
+        try {
+            response = await this.axiosInstance(this.config);
+        }
+        catch (error) {
+            node_karin_1.logger.error(error);
+        }
+        return response;
+    }
+    /** 获取最终地址（跟随重定向） */
+    async getLongLink(url = '', depth = 0) {
+        const MAX_REDIRECTS = 10;
+        if (depth > MAX_REDIRECTS) {
+            throw new Error(`重定向次数超过限制 (${MAX_REDIRECTS})`);
+        }
+        const targetUrl = this.url || url;
+        try {
+            new URL(targetUrl);
+        }
+        catch {
+            const sanitized = (0, helpers_1.sanitizeHeaders)(this.headers);
+            throw new Error(`Invalid URL: ${targetUrl || '(empty)'}, Headers: ${JSON.stringify(sanitized)}`);
+        }
+        const methods = ['head', 'get'];
+        let lastError = null;
+        for (const method of methods) {
+            try {
+                const response = await this.axiosInstance.request({
+                    url: targetUrl,
+                    method,
+                    maxRedirects: 5,
+                    validateStatus: (status) => status >= 200 && status < 400,
+                    headers: method === 'get' ? { ...this.headers, Range: 'bytes=0-0' } : this.headers,
+                    skipRetry: true
+                });
+                const finalUrl = response.request?.res?.responseUrl ?? response.config?.url ?? targetUrl;
+                return finalUrl;
+            }
+            catch (error) {
+                const axiosError = error;
+                // 处理所有重定向状态码
+                const redirectStatuses = [301, 302, 303, 307, 308];
+                if (axiosError.response?.status && redirectStatuses.includes(axiosError.response.status) && axiosError.response.headers?.location) {
+                    const location = axiosError.response.headers.location;
+                    // 处理相对路径重定向
+                    const redirectUrl = location.startsWith('http') ? location : new URL(location, targetUrl).href;
+                    node_karin_1.logger.info(`检测到${axiosError.response.status}重定向 (深度: ${depth + 1}), 目标: ${redirectUrl}`);
+                    return await this.getLongLink(redirectUrl, depth + 1);
+                }
+                if (method === 'head') {
+                    node_karin_1.logger.debug(`HEAD 请求失败 (${axiosError.code || axiosError.message})，尝试 GET 请求`);
+                    lastError = axiosError;
+                    continue;
+                }
+                lastError = axiosError;
+            }
+        }
+        const sanitized = (0, helpers_1.sanitizeHeaders)(this.headers);
+        const errorDesc = (0, helpers_1.getErrorDescription)(lastError);
+        const msg = `获取链接重定向失败: ${targetUrl} - ${errorDesc}, Headers: ${JSON.stringify(sanitized)}`;
+        node_karin_1.logger.error(msg);
+        throw new Error(msg);
+    }
+    /** 获取首个302链接 */
+    async getLocation() {
+        try {
+            const response = await this.axiosInstance({
+                method: 'GET',
+                url: this.url,
+                maxRedirects: 0,
+                validateStatus: (status) => status >= 300 && status < 400
+            });
+            return response.headers.location;
+        }
+        catch (error) {
+            if (error instanceof axios_1.AxiosError) {
+                const sanitized = (0, helpers_1.sanitizeHeaders)(this.headers);
+                node_karin_1.logger.error(`获取 ${this.url} 重定向地址失败，接口响应状态码: ${error.response?.status}, Headers: ${JSON.stringify(sanitized)}`);
+                throw new Error(error.stack);
+            }
+        }
+    }
+    /** 获取数据并处理格式化，默认 json */
+    async getData() {
+        try {
+            const result = await this.returnResult();
+            if (result.status === 504) {
+                return result;
+            }
+            if (result.status === 429) {
+                node_karin_1.logger.error('HTTP 响应状态码: 429');
+                throw new Error('ratelimit triggered, 触发 https://www.douyin.com/ 的速率限制！！！');
+            }
+            return result.data;
+        }
+        catch (error) {
+            if (error instanceof axios_1.AxiosError) {
+                const sanitized = (0, helpers_1.sanitizeHeaders)(this.headers);
+                const errorDesc = (0, helpers_1.getErrorDescription)(error);
+                throw new Error(`${errorDesc}, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`);
+            }
+            return false;
+        }
+    }
+    /**
+     * 获取响应头信息（仅首个字节）
+     * 适用于获取视频流的完整大小
+     */
+    async getHeaders() {
+        const tryRequest = async (method, extraHeaders) => {
+            const response = await this.axiosInstance.request({
+                ...this.config,
+                method,
+                responseType: 'stream',
+                maxRedirects: 5,
+                headers: {
+                    ...this.config.headers,
+                    ...extraHeaders
+                },
+                skipRetry: true,
+                validateStatus: () => true
+            });
+            const stream = response.data;
+            if (stream && typeof stream.destroy === 'function') {
+                stream.on?.('error', () => { });
+                stream.destroy();
+            }
+            if (response.status >= 200 && response.status < 400) {
+                return response;
+            }
+            node_karin_1.logger.debug(`获取响应头时 ${method} 探测返回 HTTP ${response.status}，继续尝试其他策略`);
+            return null;
+        };
+        try {
+            const headResponse = await tryRequest('HEAD');
+            if (headResponse) {
+                const totalBytes = (0, helpers_1.extractTotalBytesFromHeaders)(headResponse.headers);
+                if (totalBytes > 0 || headResponse.headers['content-type']) {
+                    return headResponse.headers;
+                }
+            }
+            const rangedResponse = await tryRequest('GET', {
+                Range: 'bytes=0-0'
+            });
+            if (rangedResponse) {
+                return rangedResponse.headers;
+            }
+            const fallbackResponse = await tryRequest('GET');
+            if (fallbackResponse) {
+                return fallbackResponse.headers;
+            }
+            const sanitized = (0, helpers_1.sanitizeHeaders)(this.headers);
+            throw new Error(`获取响应头失败: 所有探测方式均未返回有效响应, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`);
+        }
+        catch (error) {
+            if (error instanceof axios_1.AxiosError) {
+                const sanitized = (0, helpers_1.sanitizeHeaders)(this.headers);
+                const errorDesc = (0, helpers_1.getErrorDescription)(error);
+                const errorMsg = `获取响应头失败: ${errorDesc}, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`;
+                node_karin_1.logger.error(errorMsg);
+                throw new Error(errorMsg);
+            }
+            node_karin_1.logger.error(error);
+            throw error;
+        }
+    }
+    /**
+     * 获取响应头信息（完整）
+     */
+    async getHeadersFull() {
+        try {
+            const response = await this.axiosInstance({
+                ...this.config,
+                method: 'GET'
+            });
+            return response.headers;
+        }
+        catch (error) {
+            if (error instanceof axios_1.AxiosError) {
+                const sanitized = (0, helpers_1.sanitizeHeaders)(this.headers);
+                const errorDesc = (0, helpers_1.getErrorDescription)(error);
+                const errorMsg = `获取完整响应头失败: ${errorDesc}, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`;
+                node_karin_1.logger.error(errorMsg);
+                throw new Error(errorMsg);
+            }
+            node_karin_1.logger.error(error);
+            throw error;
+        }
+    }
+}
+exports.Network = Network;

package/lib/karin/module/utils/Network/ThrottleStream.js

@@ -0,0 +1,71 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.ThrottleStream = void 0;
+const node_stream_1 = require("node:stream");
+/**
+ * 限速流转换器
+ * 用于控制下载速度，避免触发服务器风控
+ */
+class ThrottleStream extends node_stream_1.Transform {
+    bytesPerSecond;
+    startTime;
+    totalBytes;
+    /**
+     * 创建限速流
+     * @param bytesPerSecond 每秒允许通过的字节数
+     */
+    constructor(bytesPerSecond) {
+        super();
+        this.bytesPerSecond = bytesPerSecond;
+        this.startTime = Date.now();
+        this.totalBytes = 0;
+    }
+    /**
+     * 动态调整速度限制
+     * @param newSpeed 新的速度限制 (bytes/s)
+     */
+    setSpeed(newSpeed) {
+        this.bytesPerSecond = newSpeed;
+        // 重置计时，避免突然的速度变化导致长时间等待
+        this.startTime = Date.now();
+        this.totalBytes = 0;
+    }
+    /**
+     * 获取当前速度限制
+     */
+    getSpeed() {
+        return this.bytesPerSecond;
+    }
+    /**
+     * 获取当前实际速度
+     */
+    getCurrentSpeed() {
+        const elapsed = (Date.now() - this.startTime) / 1000;
+        if (elapsed <= 0)
+            return 0;
+        return this.totalBytes / elapsed;
+    }
+    _transform(chunk, _encoding, callback) {
+        this.totalBytes += chunk.length;
+        // 计算已经过的时间
+        const elapsed = (Date.now() - this.startTime) / 1000;
+        // 计算按当前速度限制应该花费的时间
+        const expectedTime = this.totalBytes / this.bytesPerSecond;
+        // 如果实际时间小于预期时间，需要等待
+        const delay = Math.max(0, (expectedTime - elapsed) * 1000);
+        if (delay > 0) {
+            setTimeout(() => {
+                this.push(chunk);
+                callback();
+            }, delay);
+        }
+        else {
+            this.push(chunk);
+            callback();
+        }
+    }
+    _flush(callback) {
+        callback();
+    }
+}
+exports.ThrottleStream = ThrottleStream;