koishi-plugin-kkk 1.0.0

package/lib/karin/module/utils/MotionPhoto.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.buildGoogleMotionPhoto = void 0;
+// 参考文章 https://blog.0to1.cf/posts/cn-motion-photo-format
+// 参考文章 https://blog.zzbd.org/motion-live-photo-webui
+// 参考项目 https://github.com/flashlab/motion-live-photo
+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 Common_1 = require("./Common");
+const Config_1 = require("./Config");
+const xmpHeaderBuffer = Buffer.from('http://ns.adobe.com/xap/1.0/\u0000', 'utf8');
+const oppoExifHex = 'FFE100724578696600004D4D002A0000000800040100000400000001000005A001010004000000010000043C87690004000000010000003E011200030000000100000000000000000002928600020000000E0000005C920800040000000100000000000000006F706C75735F3833383836303800';
+const xiaomiExifHex = 'FFE1007E4578696600004D4D002A0000000800040100000400000001000005A001010004000000010000043C01120003000000010000000087690004000000010000003E000000000003889700010000000101000000920800040000000100000000928600020000000E00000068000000006F706C75735F3833383836303800';
+const huaweiHonorLiveIdFallback = 1915884;
+const isJpegBuffer = (fileBuffer) => {
+    return fileBuffer.length > 2 && fileBuffer[0] === 0xff && fileBuffer[1] === 0xd8;
+};
+const getJpegDimensions = (jpegBuffer) => {
+    let offset = 2;
+    while (offset + 9 < jpegBuffer.length) {
+        if (jpegBuffer[offset] !== 0xff) {
+            offset += 1;
+            continue;
+        }
+        const marker = jpegBuffer[offset + 1];
+        if (marker === 0xd8 || marker === 0xd9 || marker === 0x01 || (marker >= 0xd0 && marker <= 0xd7)) {
+            offset += 2;
+            continue;
+        }
+        if (offset + 3 >= jpegBuffer.length)
+            return null;
+        const segmentLength = jpegBuffer.readUInt16BE(offset + 2);
+        if (segmentLength < 2 || offset + 2 + segmentLength > jpegBuffer.length)
+            return null;
+        const isSofMarker = (marker >= 0xc0 && marker <= 0xc3) ||
+            (marker >= 0xc5 && marker <= 0xc7) ||
+            (marker >= 0xc9 && marker <= 0xcb) ||
+            (marker >= 0xcd && marker <= 0xcf);
+        if (isSofMarker && segmentLength >= 7) {
+            const height = jpegBuffer.readUInt16BE(offset + 5);
+            const width = jpegBuffer.readUInt16BE(offset + 7);
+            if (width > 0 && height > 0)
+                return { width, height };
+            return null;
+        }
+        offset += 2 + segmentLength;
+    }
+    return null;
+};
+const hasExifApp1 = (jpegBuffer) => {
+    return jpegBuffer.includes(Buffer.from('Exif\u0000\u0000', 'binary'));
+};
+const buildExifSegment = (hex, width, height) => {
+    const exifBuffer = Buffer.from(hex, 'hex');
+    exifBuffer[28] = (width >> 24) & 0xff;
+    exifBuffer[29] = (width >> 16) & 0xff;
+    exifBuffer[30] = (width >> 8) & 0xff;
+    exifBuffer[31] = width & 0xff;
+    exifBuffer[40] = (height >> 24) & 0xff;
+    exifBuffer[41] = (height >> 16) & 0xff;
+    exifBuffer[42] = (height >> 8) & 0xff;
+    exifBuffer[43] = height & 0xff;
+    return exifBuffer;
+};
+const getSystemExifHex = (system) => {
+    if (system === 'oppo')
+        return oppoExifHex;
+    if (system === 'xiaomi')
+        return xiaomiExifHex;
+    return null;
+};
+const resolveMotionPhotoSystem = () => {
+    const system = Config_1.Config.app.livePhotoSystem;
+    if (system === 'google' || system === 'xiaomi' || system === 'oppo' || system === 'huawei_honor') {
+        return system;
+    }
+    return 'google';
+};
+const buildMotionPhotoXmp = (videoLength, presentationTimestampUs, system, hdrGainMapLength) => {
+    if (system === 'oppo') {
+        // OPPO 支持 HDR GainMap 的完整 XMP 数据
+        const containerItems = [
+            '<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="image/jpeg" Item:Semantic="Primary" Item:Length="0" Item:Padding="0" /></rdf:li>'
+        ];
+        // 如果有 HDR GainMap 数据，添加 GainMap 项
+        if (hdrGainMapLength && hdrGainMapLength > 0) {
+            containerItems.push(`<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="image/jpeg" Item:Semantic="GainMap" Item:Length="${hdrGainMapLength}" Item:Padding="0" /></rdf:li>`);
+        }
+        // 添加视频项
+        containerItems.push(`<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="video/mp4" Item:Semantic="MotionPhoto" Item:Length="${videoLength}" /></rdf:li>`);
+        return ('<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 5.1.0-jc003">' +
+            '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">' +
+            '<rdf:Description rdf:about="" ' +
+            'xmlns:hdrgm="http://ns.adobe.com/hdr-gain-map/1.0/" ' +
+            'xmlns:GCamera="http://ns.google.com/photos/1.0/camera/" ' +
+            'xmlns:OpCamera="http://ns.oplus.com/photos/1.0/camera/" ' +
+            'xmlns:Container="http://ns.google.com/photos/1.0/container/" ' +
+            'xmlns:Item="http://ns.google.com/photos/1.0/container/item/" ' +
+            'hdrgm:Version="1.0" ' +
+            `GCamera:MotionPhoto="1" GCamera:MotionPhotoVersion="1" GCamera:MotionPhotoPresentationTimestampUs="${presentationTimestampUs}" ` +
+            `OpCamera:MotionPhotoPrimaryPresentationTimestampUs="${presentationTimestampUs}" OpCamera:MotionPhotoOwner="oplus" OpCamera:OLivePhotoVersion="2" OpCamera:VideoLength="${videoLength}">` +
+            '<Container:Directory><rdf:Seq>' +
+            containerItems.join('') +
+            '</rdf:Seq></Container:Directory>' +
+            '</rdf:Description>' +
+            '</rdf:RDF>' +
+            '</x:xmpmeta>');
+    }
+    if (system === 'xiaomi') {
+        return ('<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 5.1.0-jc003">' +
+            '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">' +
+            '<rdf:Description rdf:about="" ' +
+            'xmlns:GCamera="http://ns.google.com/photos/1.0/camera/" ' +
+            'xmlns:MiCamera="http://ns.xiaomi.com/photos/1.0/camera/" ' +
+            'xmlns:Container="http://ns.google.com/photos/1.0/container/" ' +
+            'xmlns:Item="http://ns.google.com/photos/1.0/container/item/" ' +
+            `GCamera:MotionPhoto="1" GCamera:MotionPhotoVersion="1" GCamera:MotionPhotoPresentationTimestampUs="${presentationTimestampUs}" ` +
+            `GCamera:MicroVideo="1" GCamera:MicroVideoVersion="1" GCamera:MicroVideoOffset="${videoLength}" GCamera:MicroVideoPresentationTimestampUs="${presentationTimestampUs}" ` +
+            'MiCamera:XMPMeta="&lt;?xml version=&apos;1.0&apos; encoding=&apos;UTF-8&apos; standalone=&apos;yes&apos; ?&gt;">' +
+            '<Container:Directory><rdf:Seq>' +
+            '<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="image/jpeg" Item:Semantic="Primary" Item:Length="0" Item:Padding="0" /></rdf:li>' +
+            `<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="video/mp4" Item:Semantic="MotionPhoto" Item:Length="${videoLength}" Item:Padding="0" /></rdf:li>` +
+            '</rdf:Seq></Container:Directory>' +
+            '</rdf:Description>' +
+            '</rdf:RDF>' +
+            '</x:xmpmeta>');
+    }
+    return ('<x:xmpmeta xmlns:x="adobe:ns:meta/" x:xmptk="Adobe XMP Core 5.1.0-jc003">' +
+        '<rdf:RDF xmlns:rdf="http://www.w3.org/1999/02/22-rdf-syntax-ns#">' +
+        '<rdf:Description rdf:about="" ' +
+        'xmlns:GCamera="http://ns.google.com/photos/1.0/camera/" ' +
+        'xmlns:Container="http://ns.google.com/photos/1.0/container/" ' +
+        'xmlns:Item="http://ns.google.com/photos/1.0/container/item/" ' +
+        `GCamera:MotionPhoto="1" GCamera:MotionPhotoVersion="1" GCamera:MotionPhotoPresentationTimestampUs="${presentationTimestampUs}">` +
+        '<Container:Directory><rdf:Seq>' +
+        '<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="image/jpeg" Item:Semantic="Primary" Item:Length="0" Item:Padding="0" /></rdf:li>' +
+        `<rdf:li rdf:parseType="Resource"><Container:Item Item:Mime="video/mp4" Item:Semantic="MotionPhoto" Item:Length="${videoLength}" Item:Padding="0" /></rdf:li>` +
+        '</rdf:Seq></Container:Directory>' +
+        '</rdf:Description>' +
+        '</rdf:RDF>' +
+        '</x:xmpmeta>');
+};
+const injectXmpToJpeg = (jpegBuffer, xmpPacket, system) => {
+    if (!isJpegBuffer(jpegBuffer)) {
+        throw new Error('输入图片不是 JPEG 格式');
+    }
+    const xmpPayload = Buffer.concat([xmpHeaderBuffer, Buffer.from(xmpPacket, 'utf8')]);
+    const app1Length = xmpPayload.length + 2;
+    if (app1Length > 65535) {
+        throw new Error('XMP 数据过大，无法写入 JPEG APP1');
+    }
+    const app1Segment = Buffer.alloc(4);
+    app1Segment[0] = 0xff;
+    app1Segment[1] = 0xe1;
+    app1Segment.writeUInt16BE(app1Length, 2);
+    const dimensions = getJpegDimensions(jpegBuffer);
+    const exifHex = getSystemExifHex(system);
+    const needExif = !hasExifApp1(jpegBuffer) && dimensions !== null && exifHex !== null;
+    const exifSegment = needExif ? buildExifSegment(exifHex, dimensions.width, dimensions.height) : null;
+    return Buffer.concat([jpegBuffer.subarray(0, 2), ...(exifSegment ? [exifSegment] : []), app1Segment, xmpPayload, jpegBuffer.subarray(2)]);
+};
+const readOrConvertToJpeg = async (imagePath) => {
+    const sourceBuffer = node_fs_1.default.readFileSync(imagePath);
+    if (isJpegBuffer(sourceBuffer)) {
+        return sourceBuffer;
+    }
+    const tempJpegPath = node_path_1.default.join(Common_1.Common.tempDri.images, `MotionPhoto_${Date.now()}_${Math.random().toString(36).slice(2)}.jpg`);
+    const result = await (0, node_karin_1.ffmpeg)(`-y -i "${imagePath}" -frames:v 1 -q:v 2 "${tempJpegPath}"`);
+    if (!result.status) {
+        throw new Error(`图片转换 JPEG 失败: ${imagePath}`);
+    }
+    try {
+        return node_fs_1.default.readFileSync(tempJpegPath);
+    }
+    finally {
+        node_fs_1.default.rmSync(tempJpegPath, { force: true });
+    }
+};
+/**
+ * 检测图片是否包含HDR GainMap数据
+ * @param imageBuffer JPEG图片缓冲区
+ * @returns HDR GainMap长度，如果没有则返回0
+ */
+const detectHdrGainMap = (imageBuffer) => {
+    try {
+        // 查找XMP数据段
+        const xmpStart = imageBuffer.indexOf('http://ns.adobe.com/xap/1.0/');
+        if (xmpStart === -1)
+            return 0;
+        // 查找HDR GainMap相关标记
+        const hdrGainMapMarker = 'Item:Semantic="GainMap"';
+        const gainMapIndex = imageBuffer.indexOf(hdrGainMapMarker, xmpStart);
+        if (gainMapIndex === -1)
+            return 0;
+        // 尝试提取GainMap长度
+        const lengthPattern = /Item:Length="(\d+)"/;
+        const xmpSection = imageBuffer.subarray(xmpStart, xmpStart + 4096).toString('utf8');
+        const gainMapSection = xmpSection.substring(xmpSection.indexOf(hdrGainMapMarker));
+        const lengthMatch = gainMapSection.match(lengthPattern);
+        if (lengthMatch && lengthMatch[1]) {
+            const length = parseInt(lengthMatch[1], 10);
+            node_karin_1.logger.debug(`检测到HDR GainMap，长度: ${length}`);
+            return length;
+        }
+        // 如果找到GainMap标记但无法提取长度，返回默认值
+        node_karin_1.logger.debug('检测到HDR GainMap标记，但无法提取长度，使用默认值');
+        return 463255; // 使用你提供的示例中的默认长度
+    }
+    catch (error) {
+        node_karin_1.logger.debug('HDR GainMap检测失败:', error);
+        return 0;
+    }
+};
+const buildGoogleMotionPhoto = async (options) => {
+    const { imagePath, videoPath, outputPath, presentationTimestampUs, hdrGainMapLength } = options;
+    try {
+        const system = resolveMotionPhotoSystem();
+        const imageBuffer = await readOrConvertToJpeg(imagePath);
+        const videoBuffer = node_fs_1.default.readFileSync(videoPath);
+        const resolvedPresentationTimestampUs = presentationTimestampUs === undefined || presentationTimestampUs < 0 ? 0 : presentationTimestampUs;
+        // 自动检测HDR GainMap（仅对OPPO系统）
+        const detectedHdrGainMapLength = system === 'oppo' ? (hdrGainMapLength ?? detectHdrGainMap(imageBuffer)) : 0;
+        const huaweiHonorFooter = Buffer.from(`v2_f35              409:1000            LIVE_${resolvedPresentationTimestampUs > 0 ? Math.floor(resolvedPresentationTimestampUs) : huaweiHonorLiveIdFallback}`, 'utf8');
+        const outputBuffer = system === 'huawei_honor'
+            ? Buffer.concat([imageBuffer, huaweiHonorFooter])
+            : (() => {
+                const xmpPacket = buildMotionPhotoXmp(videoBuffer.length, resolvedPresentationTimestampUs, system, detectedHdrGainMapLength);
+                const jpegWithXmp = injectXmpToJpeg(imageBuffer, xmpPacket, system);
+                return Buffer.concat([jpegWithXmp, videoBuffer]);
+            })();
+        node_fs_1.default.mkdirSync(node_path_1.default.dirname(outputPath), { recursive: true });
+        node_fs_1.default.writeFileSync(outputPath, outputBuffer);
+        if (system === 'oppo' && detectedHdrGainMapLength > 0) {
+            node_karin_1.logger.debug(`Motion Photo 封面生成成功(${system} with HDR): ${outputPath}`);
+        }
+        else {
+            node_karin_1.logger.debug(`Motion Photo 封面生成成功(${system}): ${outputPath}`);
+        }
+        return true;
+    }
+    catch (error) {
+        node_karin_1.logger.error('Motion Photo 封面生成失败', error);
+        return false;
+    }
+};
+exports.buildGoogleMotionPhoto = buildGoogleMotionPhoto;

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

@@ -0,0 +1,413 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.Downloader = void 0;
+exports.reportDownloadProgress = reportDownloadProgress;
+exports.reportDownloadStage = reportDownloadStage;
+exports.clearDownloadStage = clearDownloadStage;
+exports.clearDownloadProgress = clearDownloadProgress;
+exports.listActiveDownloads = listActiveDownloads;
+const node_fs_1 = __importDefault(require("node:fs"));
+const node_stream_1 = require("node:stream");
+const promises_1 = require("node:stream/promises");
+const node_karin_1 = require("../../../../compat/node-karin.js");
+const axios_1 = require("../../../../compat/axios.js");
+const helpers_1 = require("./helpers");
+const ThrottleStream_1 = require("./ThrottleStream");
+const types_1 = require("./types");
+const activeDownloads = new Map();
+/** 清掉所有「阶段」条目（真正开始传字节时调用，避免和真实进度同时显示） */
+const clearStages = () => {
+    for (const key of [...activeDownloads.keys()]) {
+        if (key.startsWith('stage:'))
+            activeDownloads.delete(key);
+    }
+};
+/** 登记一次进度（由下载器内部调用） */
+function reportDownloadProgress(filepath, bytes, total) {
+    try {
+        // 开始真正传字节了：收掉「获取下载链接」这类阶段条目，避免和真实进度同时显示
+        clearStages();
+        const name = String(filepath ?? '').split(/[\\/]/).pop() || '未知文件';
+        activeDownloads.set(filepath, { name, bytes, total, at: Date.now() });
+        if (activeDownloads.size > 64)
+            activeDownloads.delete(activeDownloads.keys().next().value);
+    }
+    catch { /* 观测失败不影响下载 */ }
+}
+/**
+ * 登记一个「还没开始下载」的阶段（获取下载链接 / 合并音轨等）。
+ *
+ * @param key 任务标识（用任务名即可，避免和真实下载的文件路径冲突）
+ * @param name 给用户看的名字
+ * @param stage 阶段说明
+ */
+function reportDownloadStage(key, name, stage) {
+    try {
+        activeDownloads.set('stage:' + key, { name, bytes: 0, total: 0, at: Date.now(), stage });
+        if (activeDownloads.size > 64)
+            activeDownloads.delete(activeDownloads.keys().next().value);
+    }
+    catch { /* 观测失败不影响流程 */ }
+}
+/** 结束阶段登记（进入真正下载或流程结束时调用） */
+function clearDownloadStage(key) {
+    activeDownloads.delete('stage:' + key);
+}
+/** 结束一次下载（成功/失败都要清掉，否则按钮会一直显示已完成的任务） */
+function clearDownloadProgress(filepath) {
+    activeDownloads.delete(filepath);
+}
+/** 当前仍在进行的下载（60 秒内有过更新才算「进行中」） */
+function listActiveDownloads() {
+    const now = Date.now();
+    const result = [];
+    for (const [key, value] of activeDownloads) {
+        if (now - value.at > 60_000) {
+            activeDownloads.delete(key);
+            continue;
+        }
+        result.push(value);
+    }
+    return result.sort((left, right) => right.at - left.at);
+}
+/**
+ * 文件下载器
+ * 支持断点续传、限速下载、自动重试
+ */
+class Downloader {
+    axiosInstance;
+    url;
+    filepath;
+    headers;
+    timeout;
+    maxRetries;
+    throttleConfig;
+    currentSpeed;
+    consecutiveResets;
+    constructor(axiosInstance, url, filepath, headers, timeout, maxRetries, throttleConfig) {
+        this.axiosInstance = axiosInstance;
+        this.url = url;
+        this.filepath = filepath;
+        this.headers = headers;
+        this.timeout = timeout;
+        this.maxRetries = maxRetries;
+        this.throttleConfig = { ...types_1.DEFAULT_THROTTLE_CONFIG, ...throttleConfig };
+        this.currentSpeed = this.throttleConfig.maxSpeed;
+        this.consecutiveResets = 0;
+    }
+    /**
+     * 执行下载
+     * @param progressCallback 进度回调
+     * @param retryCount 当前重试次数
+     */
+    async download(progressCallback, retryCount = 0) {
+        // URL 校验
+        if (!this.url || !/^https?:\/\//i.test(this.url)) {
+            const sanitized = (0, helpers_1.sanitizeHeaders)(this.headers);
+            throw new Error(`Invalid URL: ${this.url || '(empty)'}, Headers: ${JSON.stringify(sanitized)}`);
+        }
+        if (!this.filepath) {
+            throw new Error('未指定文件保存路径: filepath 为空');
+        }
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), this.timeout);
+        let intervalId = null;
+        let throttleStream = null;
+        let writer = null;
+        try {
+            // 检查断点续传
+            let startByte = 0;
+            if (node_fs_1.default.existsSync(this.filepath)) {
+                const stats = node_fs_1.default.statSync(this.filepath);
+                // 由于 stream.pipeline 出错时可能丢失内部缓冲区数据（最多约 32KB），
+                // 保守起见回退 256KB 重新下载，避免文件损坏
+                startByte = Math.max(0, stats.size - 256 * 1024);
+                if (startByte > 0 && startByte < stats.size) {
+                    // 截断文件到回退位置，避免 r+ 模式下旧数据残留在文件末尾
+                    node_fs_1.default.truncateSync(this.filepath, startByte);
+                    node_karin_1.logger.debug(`检测到部分下载文件，截断到 ${(0, helpers_1.formatBytes)(startByte)} 后重新下载（回退 256KB 安全裕量）`);
+                }
+                else if (startByte > 0) {
+                    node_karin_1.logger.debug(`检测到部分下载文件，从 ${(0, helpers_1.formatBytes)(startByte)} 处继续下载（回退 256KB 安全裕量）`);
+                }
+                else {
+                    node_karin_1.logger.debug('检测到部分下载文件，文件较小，将重新下载');
+                }
+            }
+            // 构建请求配置
+            const requestConfig = {
+                url: this.url,
+                method: 'GET',
+                responseType: 'stream',
+                signal: controller.signal,
+                headers: { ...this.headers },
+                skipRetry: true
+            };
+            // 断点续传
+            if (startByte > 0) {
+                requestConfig.headers = {
+                    ...requestConfig.headers,
+                    Range: `bytes=${startByte}-`
+                };
+            }
+            node_karin_1.logger.debug('开始下载流', {
+                url: this.url,
+                headers: (0, helpers_1.sanitizeHeaders)(requestConfig.headers),
+                throttleEnabled: this.throttleConfig.enabled,
+                currentSpeed: this.throttleConfig.enabled ? (0, helpers_1.formatBytes)(this.currentSpeed) + '/s' : '不限速'
+            });
+            const response = await this.axiosInstance(requestConfig);
+            clearTimeout(timeoutId);
+            // 检查 HTTP 状态码
+            // 416 Range Not Satisfiable
+            if (response.status === 416) {
+                node_karin_1.logger.warn('服务器返回 416，文件可能已下载完成，验证文件大小...');
+                if (node_fs_1.default.existsSync(this.filepath)) {
+                    const stats = node_fs_1.default.statSync(this.filepath);
+                    node_karin_1.logger.debug(`当前文件大小: ${(0, helpers_1.formatBytes)(stats.size)}`);
+                    // 如果文件大小合理（大于 1KB），认为下载完成
+                    if (stats.size > 1024) {
+                        node_karin_1.logger.debug('文件大小合理，认为下载已完成');
+                        return {
+                            filepath: this.filepath,
+                            totalBytes: stats.size
+                        };
+                    }
+                    else {
+                        // 文件太小，删除并重新下载
+                        node_karin_1.logger.warn('文件太小，删除并重新下载');
+                        node_fs_1.default.unlinkSync(this.filepath);
+                        return this.download(progressCallback, retryCount + 1);
+                    }
+                }
+            }
+            if (response.status !== 200 && response.status !== 206) {
+                node_karin_1.logger.error(`下载失败: HTTP ${response.status}, URL: ${this.url}`);
+                node_karin_1.logger.error(`响应头: ${JSON.stringify(response.headers)}`);
+                // 如果响应体很小，可能是错误信息，尝试读取
+                if (response.headers['content-length'] && parseInt(response.headers['content-length']) < 10240) {
+                    let errorBody = '';
+                    response.data.on('data', (chunk) => {
+                        errorBody += chunk.toString();
+                    });
+                    await new Promise((resolve) => setTimeout(resolve, 100));
+                    node_karin_1.logger.error(`响应内容: ${errorBody}`);
+                }
+                throw new Error(`HTTP ${response.status}: ${this.url}`);
+            }
+            // 检查服务器是否支持断点续传
+            const supportsRange = response.status === 206;
+            if (startByte > 0 && !supportsRange) {
+                node_karin_1.logger.warn('服务器不支持断点续传，将重新下载整个文件');
+                if (node_fs_1.default.existsSync(this.filepath)) {
+                    node_fs_1.default.unlinkSync(this.filepath);
+                }
+                startByte = 0;
+            }
+            // 验证 206 响应的 Content-Range 起始位置，防止 CDN 返回错误范围导致文件损坏
+            if (supportsRange && response.headers['content-range']) {
+                const contentRange = String(response.headers['content-range']);
+                const rangeMatch = contentRange.match(/bytes\s*(\d+)-\d+\/\d+/);
+                if (rangeMatch) {
+                    const responseStartByte = Number.parseInt(rangeMatch[1], 10);
+                    if (responseStartByte !== startByte) {
+                        node_karin_1.logger.warn(`Content-Range 起始位置不匹配: 请求 ${startByte}, 实际 ${responseStartByte}，将重新下载`);
+                        if (node_fs_1.default.existsSync(this.filepath)) {
+                            node_fs_1.default.unlinkSync(this.filepath);
+                        }
+                        startByte = 0;
+                    }
+                }
+            }
+            // 解析内容长度
+            const rawContentLength = response.headers['content-length'];
+            const contentLength = Number.parseInt(rawContentLength ?? '-1', 10);
+            if (Number.isNaN(contentLength)) {
+                const sanitized = (0, helpers_1.sanitizeHeaders)(this.headers);
+                throw new Error(`无效的 content-length 响应头, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`);
+            }
+            const totalBytes = supportsRange ? startByte + contentLength : contentLength;
+            let downloadedBytes = startByte;
+            let lastPrintedPercentage = -1;
+            // 创建写入流
+            // 使用 r+ 模式和 start 选项，从指定位置覆盖写入，避免 append 模式导致的数据错位
+            writer = node_fs_1.default.createWriteStream(this.filepath, {
+                flags: startByte > 0 ? 'r+' : 'w',
+                start: startByte > 0 ? startByte : undefined
+            });
+            // 进度回调
+            const printProgress = () => {
+                if (totalBytes > 0) {
+                    const progressPercentage = Math.floor((downloadedBytes / totalBytes) * 100);
+                    if (progressPercentage !== lastPrintedPercentage) {
+                        progressCallback(downloadedBytes, totalBytes);
+                        lastPrintedPercentage = progressPercentage;
+                    }
+                }
+                else {
+                    progressCallback(downloadedBytes, totalBytes);
+                }
+                // 登记进度：面板上的「📊 查询下载进度」按钮读的就是这里
+                reportDownloadProgress(this.filepath, downloadedBytes, totalBytes);
+            };
+            const interval = totalBytes > 0 && totalBytes < 10 * 1024 * 1024 ? 1000 : 500;
+            intervalId = setInterval(printProgress, interval);
+            // 创建计数流
+            const counterStream = new node_stream_1.Transform({
+                transform(chunk, encoding, callback) {
+                    downloadedBytes += chunk.length;
+                    callback(null, chunk);
+                }
+            });
+            // 根据配置决定是否使用限速流
+            if (this.throttleConfig.enabled) {
+                throttleStream = new ThrottleStream_1.ThrottleStream(this.currentSpeed);
+                node_karin_1.logger.debug(`启用限速下载: ${(0, helpers_1.formatBytes)(this.currentSpeed)}/s`);
+                await (0, promises_1.pipeline)(response.data, throttleStream, counterStream, writer);
+            }
+            else {
+                await (0, promises_1.pipeline)(response.data, counterStream, writer);
+            }
+            if (intervalId)
+                clearInterval(intervalId);
+            // pipeline 已经等待所有流完成，包括 writer 的 finish 事件
+            node_karin_1.logger.debug('文件下载并写入完成');
+            // 验证文件大小
+            if (node_fs_1.default.existsSync(this.filepath)) {
+                const stats = node_fs_1.default.statSync(this.filepath);
+                const actualSize = stats.size;
+                const expectedSize = totalBytes > 0 ? totalBytes : downloadedBytes;
+                // 检查文件是否太小（可能是错误响应）
+                if (actualSize < 1024 && expectedSize < 1024) {
+                    node_karin_1.logger.error(`下载的文件异常小 (${(0, helpers_1.formatBytes)(actualSize)})，可能是错误响应`);
+                    // 尝试读取文件内容
+                    try {
+                        const content = node_fs_1.default.readFileSync(this.filepath, 'utf-8');
+                        node_karin_1.logger.error(`文件内容: ${content}`);
+                    }
+                    catch {
+                        node_karin_1.logger.error('无法读取文件内容（可能是二进制文件）');
+                    }
+                    throw new Error(`下载的文件异常小: ${(0, helpers_1.formatBytes)(actualSize)}，可能是错误响应或链接失效`);
+                }
+                if (actualSize < expectedSize) {
+                    node_karin_1.logger.warn(`文件大小不匹配: 实际 ${(0, helpers_1.formatBytes)(actualSize)}, 预期 ${(0, helpers_1.formatBytes)(expectedSize)}`);
+                    node_karin_1.logger.warn(`差异: ${(0, helpers_1.formatBytes)(expectedSize - actualSize)} (${(((expectedSize - actualSize) / expectedSize) * 100).toFixed(2)}%)`);
+                    // 如果差异大于 10KB，认为下载不完整
+                    if (expectedSize - actualSize > 10 * 1024) {
+                        throw new Error(`文件下载不完整: 实际 ${(0, helpers_1.formatBytes)(actualSize)}, 预期 ${(0, helpers_1.formatBytes)(expectedSize)}`);
+                    }
+                }
+                else {
+                    node_karin_1.logger.debug(`文件大小验证通过: ${(0, helpers_1.formatBytes)(actualSize)}`);
+                }
+            }
+            // 下载成功，重置连续重置计数
+            this.consecutiveResets = 0;
+            clearDownloadProgress(this.filepath);
+            return {
+                filepath: this.filepath,
+                totalBytes: totalBytes > 0 ? totalBytes : downloadedBytes
+            };
+        }
+        catch (error) {
+            clearTimeout(timeoutId);
+            if (intervalId)
+                clearInterval(intervalId);
+            // 失败/中断也要清掉，不然「查询下载进度」会一直卡在旧任务上
+            clearDownloadProgress(this.filepath);
+            const isRecoverable = (0, helpers_1.isRecoverableNetworkError)(error);
+            const isThrottling = (0, helpers_1.isThrottlingError)(error);
+            const errorDesc = (0, helpers_1.getErrorDescription)(error);
+            if (error instanceof axios_1.AxiosError) {
+                const sanitized = (0, helpers_1.sanitizeHeaders)(this.headers);
+                node_karin_1.logger.error(`请求失败: ${errorDesc}, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`);
+            }
+            else {
+                node_karin_1.logger.error(`下载失败: ${errorDesc}`);
+            }
+            // 如果是断流错误，自动降速
+            if (isThrottling && this.throttleConfig.enabled) {
+                this.consecutiveResets++;
+                const newSpeed = Math.max(this.currentSpeed * this.throttleConfig.autoReduceRatio, this.throttleConfig.minSpeed);
+                if (newSpeed < this.currentSpeed) {
+                    node_karin_1.logger.warn(`检测到服务器断流 (连续 ${this.consecutiveResets} 次)，自动降速: ${(0, helpers_1.formatBytes)(this.currentSpeed)}/s -> ${(0, helpers_1.formatBytes)(newSpeed)}/s`);
+                    this.currentSpeed = newSpeed;
+                }
+                else {
+                    node_karin_1.logger.warn(`已达到最低速度限制 ${(0, helpers_1.formatBytes)(this.throttleConfig.minSpeed)}/s，无法继续降速`);
+                }
+            }
+            const nextDelay = (0, helpers_1.calculateBackoffDelay)(retryCount);
+            if (retryCount < this.maxRetries) {
+                // 等待 writer 完全关闭，确保异步写入操作已完成，避免 stat 获取到不准确的文件大小
+                if (writer && !(writer.closed ?? false)) {
+                    const ws = writer;
+                    await new Promise((resolve) => {
+                        const timeout = setTimeout(() => {
+                            ws.off('close', onClose);
+                            resolve();
+                        }, 1000);
+                        const onClose = () => {
+                            clearTimeout(timeout);
+                            resolve();
+                        };
+                        ws.once('close', onClose);
+                    });
+                }
+                if (isRecoverable && node_fs_1.default.existsSync(this.filepath)) {
+                    const stats = node_fs_1.default.statSync(this.filepath);
+                    node_karin_1.logger.warn(`检测到可恢复的网络错误，保留已下载的 ${(0, helpers_1.formatBytes)(stats.size)} 数据`);
+                    node_karin_1.logger.warn(`正在重试下载... (${retryCount + 1}/${this.maxRetries})，将在 ${nextDelay / 1000} 秒后使用断点续传重试`);
+                }
+                else {
+                    node_karin_1.logger.warn(`正在重试下载... (${retryCount + 1}/${this.maxRetries})，将在 ${nextDelay / 1000} 秒后重试`);
+                }
+                await new Promise((resolve) => setTimeout(resolve, nextDelay));
+                return this.download(progressCallback, retryCount + 1);
+            }
+            else {
+                // 最终失败处理
+                if (node_fs_1.default.existsSync(this.filepath)) {
+                    const stats = node_fs_1.default.statSync(this.filepath);
+                    if (isRecoverable && stats.size > 0) {
+                        node_karin_1.logger.warn(`下载失败但保留了部分文件 (${(0, helpers_1.formatBytes)(stats.size)}): ${this.filepath}`);
+                        node_karin_1.logger.warn('这可能是由于网络环境变化或服务器风控导致的，文件已保留供后续恢复');
+                        if (isThrottling) {
+                            node_karin_1.logger.warn('建议: 服务器可能有下载速度限制，请尝试在配置中降低 maxSpeed 参数');
+                        }
+                    }
+                    else {
+                        try {
+                            node_fs_1.default.unlinkSync(this.filepath);
+                            node_karin_1.logger.debug('已清理部分下载的文件');
+                        }
+                        catch (cleanupError) {
+                            node_karin_1.logger.warn('清理部分下载文件失败:', cleanupError);
+                        }
+                    }
+                }
+                const sanitized = (0, helpers_1.sanitizeHeaders)(this.headers);
+                throw new Error(`在 ${this.maxRetries} 次尝试后下载失败: ${errorDesc}, URL: ${this.url}, Headers: ${JSON.stringify(sanitized)}`);
+            }
+        }
+    }
+    /**
+     * 手动设置下载速度
+     * @param speed 速度 (bytes/s)
+     */
+    setSpeed(speed) {
+        this.currentSpeed = Math.max(speed, this.throttleConfig.minSpeed);
+        node_karin_1.logger.debug(`手动设置下载速度: ${(0, helpers_1.formatBytes)(this.currentSpeed)}/s`);
+    }
+    /**
+     * 获取当前速度设置
+     */
+    getSpeed() {
+        return this.currentSpeed;
+    }
+}
+exports.Downloader = Downloader;