@iflyrpa/actions 4.0.0-beta.8 → 5.0.0-beta.1

package/dist/bundle.js

@@ -8733,8 +8733,10 @@ var __webpack_exports__ = {};
         navigator: ()=>_navigator,
         origin: ()=>utils_origin
     });
-    var package_namespaceObject = JSON.parse('{"i8":"1.0.0-beta.0"}');
-    var package_namespaceObject_0 = JSON.parse('{"i8":"4.0.0-beta.7"}');
+    var package_namespaceObject = {
+        i8: "0.1.2"
+    };
+    var package_namespaceObject_0 = JSON.parse('{"i8":"4.0.1-beta.0"}');
     const external_node_fs_namespaceObject = require("node:fs");
     var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
     const external_node_http_namespaceObject = require("node:http");
@@ -23366,7 +23368,8 @@ var __webpack_exports__ = {};
                         url: error.config?.url,
                         isProxyRequest: !!(error.config && (error.config.httpAgent || error.config.httpsAgent)),
                         params: error.config?.params,
-                        data: error.config?.data
+                        data: error.config?.data,
+                        serverDate: error.response?.headers?.date
                     }
                 };
                 if (foundError) Object.assign(errorResponse, foundError);
@@ -23444,7 +23447,7 @@ var __webpack_exports__ = {};
                 try {
                     this.proxyInfo = agent ? `${agent.ip}:${agent.port}` : void 0;
                     const controller = new AbortController();
-                    const timeoutId = setTimeout(()=>controller.abort(), reqTimeout);
+                    const timeoutId = setTimeout(()=>controller.abort(), reqTimeout + 500);
                     const response = await this.apiClient({
                         ...config,
                         timeout: reqTimeout,
@@ -23468,7 +23471,7 @@ var __webpack_exports__ = {};
                         599
                     ].includes(handledError.code);
                     if (Rtimes < retries && isRetry) {
-                        this.logger?.info(`进入第${Rtimes + 1}次重试！`);
+                        this.logger?.info(`进入第${Rtimes + 1}次重试！错误码: ${handledError.code}`);
                         await new Promise((resolve)=>setTimeout(resolve, retryDelay));
                         return sessionRt(Rtimes + 1);
                     }
@@ -28653,23 +28656,26 @@ var __webpack_exports__ = {};
                     };
                 }
             case types_ExecutionState.SUCCESS:
-                await updateTaskState?.({
-                    state: types_TaskState.SUCCESS,
-                    result: {
-                        cookie: JSON.stringify(await task.steelBrowserContext?.cookies()).replace(/\\"/g, ""),
-                        token,
-                        userInfo: userInfo
-                    }
-                });
-                return {
-                    code: 0,
-                    message: "成功",
-                    data: {
-                        cookie: JSON.stringify(await task.steelBrowserContext?.cookies()).replace(/\\"/g, ""),
-                        token,
-                        userInfo
-                    }
-                };
+                {
+                    const cookie = JSON.stringify(await task.steelBrowserContext?.cookies());
+                    await updateTaskState?.({
+                        state: types_TaskState.SUCCESS,
+                        result: {
+                            cookie,
+                            token,
+                            userInfo: userInfo
+                        }
+                    });
+                    return {
+                        code: 0,
+                        message: "成功",
+                        data: {
+                            cookie,
+                            token,
+                            userInfo
+                        }
+                    };
+                }
             default:
                 return {
                     code: 500,
@@ -29026,20 +29032,11 @@ var __webpack_exports__ = {};
     };
     const rpa_rpaAction = async (task, params)=>{
         const tmpCachePath = task.getTmpPath();
-        const commonCookies = {
-            path: "/",
-            secure: true,
-            domain: "baijiahao.baidu.com",
-            url: "https://baijiahao.baidu.com",
-            httpOnly: true
-        };
+        const validCookies = (params.cookies || []).filter((it)=>it.name && it.value && "undefined" !== it.value);
         const page = await task.createPage({
             show: task.debug,
             url: params.url || "https://baijiahao.baidu.com/builder/rc/edit?type=news&is_from_cms=1",
-            cookies: params.cookies?.map((it)=>({
-                    ...it,
-                    ...commonCookies
-                })) || []
+            cookies: validCookies
         });
         page.setDefaultTimeout(60000);
         page.setDefaultNavigationTimeout(60000);
@@ -30572,6 +30569,8 @@ var __webpack_exports__ = {};
     }
     new Xhshow();
     const sessionCheck_xsEncrypt = new Xhshow();
+    let lastEnvLogTime = 0;
+    const ENV_LOG_INTERVAL_MS = 5000;
     const SessionCheckResultSchema = classic_schemas_object({
         isValidSession: classic_schemas_boolean()
     });
@@ -30636,35 +30635,33 @@ var __webpack_exports__ = {};
         }, "微信账号有效性检测完成！");
     };
     const XhsSessionCheck = async (_task, params)=>{
-        const logger = _task.logger;
-        const startedAt = Date.now();
+        const now = Date.now();
+        const shouldLogEnv = now - lastEnvLogTime >= ENV_LOG_INTERVAL_MS;
+        if (shouldLogEnv) {
+            lastEnvLogTime = now;
+            _task.logger?.debug("[XhsSessionCheck] 环境信息", {
+                processType: process.type,
+                pid: process.pid,
+                nodeVersion: process.version,
+                platform: process.platform,
+                memoryUsage: {
+                    heapUsed: `${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)} MB`,
+                    heapTotal: `${Math.round(process.memoryUsage().heapTotal / 1024 / 1024)} MB`
+                },
+                accountId: params.accountId,
+                hasProxy: !!(params.proxyLoc || params.localIP)
+            });
+        }
         const check = {
             isValidSession: false,
             isValidWebSession: false
         };
-        const cookieNames = params.cookies.map((it)=>it.name);
-        logger?.info("[XhsSessionCheck] 开始执行小红书账号有效性检测", {
-            accountId: params.accountId,
-            proxyLoc: params.proxyLoc,
-            localIP: params.localIP,
-            willUseProxyAgent: !!params.localIP,
-            cookieCount: params.cookies.length,
-            cookieNames,
-            hasA1: cookieNames.includes("a1"),
-            hasWebSession: cookieNames.includes("web_session")
-        });
         const a1Cookie = params.cookies.find((it)=>"a1" === it.name)?.value;
-        if (!a1Cookie) {
-            logger?.warn("[XhsSessionCheck] 缺失关键 cookie a1，提前返回", {
-                accountId: params.accountId,
-                cookieNames
-            });
-            return {
-                code: 414,
-                message: "账号数据异常，请重新绑定账号后重试。",
-                data: check
-            };
-        }
+        if (!a1Cookie) return {
+            code: 414,
+            message: "账号数据异常，请重新绑定账号后重试。",
+            data: check
+        };
         const headers = {
             cookie: params.cookies.map((it)=>`${it.name}=${it.value}`).join(";"),
             referer: "https://creator.xiaohongshu.com/new/home?source=official"
@@ -30691,7 +30688,31 @@ var __webpack_exports__ = {};
             if (cookie.name && cookie.value) acc[cookie.name] = cookie.value;
             return acc;
         }, {});
-        const loginBaseXsHeader = sessionCheck_xsEncrypt.signHeadersGet(loginBasePath, recordCookie, "xhs-pc-web", null);
+        let loginBaseXsHeader;
+        try {
+            loginBaseXsHeader = sessionCheck_xsEncrypt.signHeadersGet(loginBasePath, recordCookie, "xhs-pc-web", null);
+        } catch (signError) {
+            _task.logger?.error("[XhsSessionCheck] 签名生成失败 - 环境快照", {
+                accountId: params.accountId,
+                error: signError instanceof Error ? signError.message : String(signError),
+                stack: _task.debug ? signError instanceof Error ? signError.stack : void 0 : void 0,
+                hasA1: !!recordCookie.a1,
+                env: {
+                    processType: process.type,
+                    memoryUsage: {
+                        heapUsed: `${Math.round(process.memoryUsage().heapUsed / 1024 / 1024)} MB`,
+                        heapTotal: `${Math.round(process.memoryUsage().heapTotal / 1024 / 1024)} MB`
+                    },
+                    hasProxy: !!(params.proxyLoc || params.localIP),
+                    timeSinceLastLog: Date.now() - lastEnvLogTime
+                }
+            });
+            return {
+                code: 500,
+                message: "账号签名生成失败，请稍后重试。",
+                data: check
+            };
+        }
         const baseInfoStart = Date.now();
         const _baseInfo = http.api({
             method: "get",
@@ -30701,75 +30722,44 @@ var __webpack_exports__ = {};
         }, {
             retries: 3,
             retryDelay: 20,
-            timeout: 3000
-        }).then((res)=>{
-            logger?.info("[XhsSessionCheck] creator base 接口请求成功", {
-                accountId: params.accountId,
-                duration: Date.now() - baseInfoStart,
-                code: res?.code,
-                msg: res?.msg,
-                proxyInfo: http.proxyInfo
-            });
-            return res;
+            timeout: 5000
         }).catch((e)=>{
-            logger?.warn("[XhsSessionCheck] creator base 接口请求失败", {
+            const clientTimestamp = Date.now();
+            const serverDate = e?.extra?.serverDate;
+            const serverTimestamp = serverDate ? new Date(serverDate).getTime() : null;
+            const timeDriftMs = serverTimestamp ? clientTimestamp - serverTimestamp : null;
+            _task.logger?.warn("[XhsSessionCheck] creator base 接口请求失败", {
                 accountId: params.accountId,
                 duration: Date.now() - baseInfoStart,
                 code: e?.code,
                 message: e?.message,
                 data: e?.data,
                 extra: e?.extra,
-                proxyInfo: http.proxyInfo
+                proxyInfo: http.proxyInfo,
+                clientTimestamp,
+                serverDate,
+                serverTimestamp,
+                timeDriftMs,
+                isLikelyClockDrift: null !== timeDriftMs && Math.abs(timeDriftMs) > 300000
             });
             return e.data;
         });
-        const webSessionStart = Date.now();
         const _web_session = http.api({
             method: "get",
             url: "https://edith.xiaohongshu.com/api/sns/web/unread_count"
         }, {
             retries: 3,
             retryDelay: 20,
-            timeout: 3000
-        }).then((res)=>{
-            logger?.info("[XhsSessionCheck] edith unread_count 接口请求成功", {
-                accountId: params.accountId,
-                duration: Date.now() - webSessionStart,
-                code: res?.code,
-                msg: res?.msg,
-                proxyInfo: http.proxyInfo
-            });
-            return res;
-        }).catch((e)=>{
-            logger?.warn("[XhsSessionCheck] edith unread_count 接口请求失败", {
-                accountId: params.accountId,
-                duration: Date.now() - webSessionStart,
-                code: e?.code,
-                message: e?.message,
-                data: e?.data,
-                extra: e?.extra,
-                proxyInfo: http.proxyInfo
-            });
-            throw e;
+            timeout: 5000
         });
         const [baseInfo, web_session] = await Promise.all([
             _baseInfo,
             _web_session
         ]);
         if (baseInfo?.code === 0) check.isValidSession = true;
-        if (0 === web_session.code) check.isValidWebSession = true;
-        const _isSuccess = baseInfo?.code === web_session.code;
+        if (web_session?.code === 0) check.isValidWebSession = true;
+        baseInfo?.code, web_session?.code;
         const message = `小红书账号有效性检测成功${_task.debug ? ` ${http.proxyInfo}` : ""}`;
-        logger?.info("[XhsSessionCheck] 检测完成", {
-            accountId: params.accountId,
-            totalDuration: Date.now() - startedAt,
-            baseInfoCode: baseInfo?.code,
-            webSessionCode: web_session?.code,
-            isValidSession: check.isValidSession,
-            isValidWebSession: check.isValidWebSession,
-            codeAligned: _isSuccess,
-            proxyInfo: http.proxyInfo
-        });
         return success(check, message);
     };
     const BjhSessionCheck = async (_task, params)=>{
@@ -34789,7 +34779,10 @@ var __webpack_exports__ = {};
             task.logger.info(`拦截器收到响应response.data: ${JSON.stringify(response.data)} `);
             decision = parseVerifyPassportDecision(response.headers["x-tt-verify-passport-decision"]);
             if (needsVerification(decision)) {
-                task.logger.info(`需要验证: ${JSON.stringify(decision)}`);
+                task.logger.warn(`检测到需要验证: ${JSON.stringify(decision)}`);
+                task.logger.warn(`验证类型: ${decision?.verify_ways?.join(", ")}`);
+                task.logger.warn(`验证标题: ${decision?.verify_title}`);
+                task.logger.warn(`验证描述: ${decision?.verify_desc}`);
                 return;
             }
             if (!response || !response.data) return;
@@ -34816,38 +34809,116 @@ var __webpack_exports__ = {};
             });
             return utils_response(0, message, data);
         }
-        const webProtectData = JSON.parse(JSON.parse(params.extraParam["security-sdk/s_sdk_sign_data_key/web_protect"] || "{}").data || "{}");
-        const ticket = webProtectData.ticket;
-        const ts_sign = webProtectData.ts_sign;
-        const ec_privateKey = JSON.parse(JSON.parse(params.extraParam["security-sdk/s_sdk_crypt_sdk"] || "{}").data || "{}").ec_privateKey;
-        const certificate = JSON.parse(params.extraParam["security-sdk/s_sdk_server_cert_key"] || "{}").cert;
+        let webProtectData;
+        try {
+            webProtectData = JSON.parse(JSON.parse(params.extraParam["security-sdk/s_sdk_sign_data_key/web_protect"] || "{}").data || "{}");
+            if (!webProtectData.ticket || !webProtectData.ts_sign || !webProtectData.client_cert) {
+                task.logger.error(`webProtectData 关键字段缺失: ${JSON.stringify(webProtectData)}`);
+                return utils_response(414, "安全参数 webProtectData 不完整，请重新获取后重试", "");
+            }
+        } catch (error) {
+            task.logger.error(`解析 webProtectData 失败: ${error}`);
+            return utils_response(414, "安全参数 webProtectData 解析失败，请重新获取后重试", "");
+        }
+        let ticket = webProtectData.ticket;
+        let ts_sign = webProtectData.ts_sign;
+        const serverDataCookie = params.cookies.find((it)=>"bd_ticket_guard_server_data" === it.name)?.value;
+        if (serverDataCookie) try {
+            const decoded = JSON.parse(Buffer.from(decodeURIComponent(serverDataCookie), "base64").toString("utf8"));
+            if (decoded.ticket && decoded.ts_sign) {
+                if (decoded.ticket !== ticket) task.logger.info("使用 cookie 中的最新 ticket（web_protect 已过期）");
+                ticket = decoded.ticket;
+                ts_sign = decoded.ts_sign;
+            }
+        } catch (error) {
+            task.logger.warn(`解析 bd_ticket_guard_server_data 失败，回退到 web_protect: ${error}`);
+        }
+        let ec_privateKey;
+        try {
+            ec_privateKey = JSON.parse(JSON.parse(params.extraParam["security-sdk/s_sdk_crypt_sdk"] || "{}").data || "{}").ec_privateKey;
+            if (!ec_privateKey) {
+                task.logger.error("ec_privateKey 为空");
+                return utils_response(414, "安全参数 ec_privateKey 缺失，请重新获取后重试", "");
+            }
+        } catch (error) {
+            task.logger.error(`解析 ec_privateKey 失败: ${error}`);
+            return utils_response(414, "安全参数 ec_privateKey 解析失败，请重新获取后重试", "");
+        }
+        let certificate;
+        try {
+            certificate = JSON.parse(params.extraParam["security-sdk/s_sdk_server_cert_key"] || "{}").cert;
+            if (!certificate) {
+                task.logger.error("certificate 为空");
+                return utils_response(414, "安全参数 certificate 缺失，请重新获取后重试", "");
+            }
+        } catch (error) {
+            task.logger.error(`解析 certificate 失败: ${error}`);
+            return utils_response(414, "安全参数 certificate 解析失败，请重新获取后重试", "");
+        }
         const ree_public_key = webProtectData.client_cert.replace("pub.", "");
-        task.logger.info(`生成 bdTicketGuardClientData 的参数: ticket: ${ticket}, ts_sign: ${ts_sign}, ec_privateKey: ${ec_privateKey}, certificate: ${certificate}, ree_public_key: ${ree_public_key}`);
-        const bdTicketGuardClientData = getBdV2({
-            ticket,
-            ts_sign: ts_sign,
-            ec_privateKey: ec_privateKey,
-            certificate: certificate,
-            bd_ticket_guard_ree_public_key: ree_public_key
-        });
-        task.logger.info("bdTicketGuardClientData", {
-            bdTicketGuardClientData
-        });
+        task.logger.info(`生成 bdTicketGuardClientData 的参数: ticket: ${ticket?.substring(0, 20)}..., ts_sign: ${ts_sign}, ree_public_key: ${ree_public_key?.substring(0, 20)}...`);
+        let bdTicketGuardClientData;
+        try {
+            bdTicketGuardClientData = getBdV2({
+                ticket,
+                ts_sign: ts_sign,
+                ec_privateKey: ec_privateKey,
+                certificate: certificate,
+                bd_ticket_guard_ree_public_key: ree_public_key
+            });
+            if (!bdTicketGuardClientData || !bdTicketGuardClientData["headers_bd_ticket_guard_client_data"]) {
+                task.logger.error(`bdTicketGuardClientData 生成失败或不完整: ${JSON.stringify(bdTicketGuardClientData)}`);
+                return utils_response(414, "安全参数 bdTicketGuardClientData 生成失败，请重新获取后重试", "");
+            }
+        } catch (error) {
+            task.logger.error(`生成 bdTicketGuardClientData 失败: ${error}`);
+            return utils_response(414, "安全参数 bdTicketGuardClientData 生成异常，请重新获取后重试", "");
+        }
+        task.logger.info("bdTicketGuardClientData 生成成功");
         const publishQuery = {
             ...publishParams,
             a_bogus: ""
         };
         const queryString = new URLSearchParams(publishQuery).toString();
-        const aBogus = mock_getABogus(`https://creator.douyin.com/web/api/media/aweme/create_v2/?${queryString}`, publishData, userAgent);
+        let aBogus;
+        try {
+            aBogus = mock_getABogus(`https://creator.douyin.com/web/api/media/aweme/create_v2/?${queryString}`, publishData, userAgent);
+            if (!aBogus || aBogus.length < 10) {
+                task.logger.error(`a_bogus 生成异常，长度过短: ${aBogus}`);
+                return utils_response(414, "安全参数 a_bogus 生成失败，请重试", "");
+            }
+            task.logger.info(`a_bogus 生成成功: ${aBogus.substring(0, 20)}...`);
+        } catch (error) {
+            task.logger.error(`生成 a_bogus 失败: ${error}`);
+            return utils_response(414, "安全参数 a_bogus 生成异常，请重试", "");
+        }
         publishQuery.a_bogus = aBogus;
         const publishQueryParams = new URLSearchParams(publishQuery).toString();
-        const csrfToken = mock_generateCsrfTokenAdvanced({
-            cookies: params.cookies,
-            url: "https://creator.douyin.com/web/api/media/aweme/create_v2/",
-            method: "POST",
-            userAgent
-        });
-        const sessionDtrait = mock_generateDtrait("/web/api/media/aweme/create_v2/");
+        let csrfToken;
+        try {
+            csrfToken = mock_generateCsrfTokenAdvanced({
+                cookies: params.cookies,
+                url: "https://creator.douyin.com/web/api/media/aweme/create_v2/",
+                method: "POST",
+                userAgent
+            });
+            if (!csrfToken || csrfToken.length < 10) {
+                task.logger.error(`csrfToken 生成异常，长度过短: ${csrfToken}`);
+                return utils_response(414, "安全参数 csrfToken 生成失败，请重试", "");
+            }
+            task.logger.info(`csrfToken 生成成功: ${csrfToken.substring(0, 20)}...`);
+        } catch (error) {
+            task.logger.error(`生成 csrfToken 失败: ${error}`);
+            return utils_response(414, "安全参数 csrfToken 生成异常，请重试", "");
+        }
+        let sessionDtrait;
+        try {
+            sessionDtrait = mock_generateDtrait("/web/api/media/aweme/create_v2/");
+            task.logger.info(`sessionDtrait 生成成功: ${sessionDtrait || "(空)"}`);
+        } catch (error) {
+            task.logger.error(`生成 sessionDtrait 失败: ${error}`);
+            return utils_response(414, "安全参数 sessionDtrait 生成异常，请重试", "");
+        }
         task.logger.info("发布数据", {
             data: JSON.stringify(publishData)
         });
@@ -43454,6 +43525,33 @@ var __webpack_exports__ = {};
     const encode_mnsv2 = __webpack_require__("./src/utils/xhs_ob/x_s.encoder.js");
     const xiaohongshuLogin_rpa_server_scanRetryMaxCount = 60;
     const xiaohongshuLogin_rpa_server_waitQrcodeResultMaxTime = 2000 * xiaohongshuLogin_rpa_server_scanRetryMaxCount;
+    async function collectCookiesWithA1(task) {
+        const hasA1 = (cookies)=>cookies.some((c)=>"a1" === c.name && !!c.value);
+        let cookies = await task.steelBrowserContext?.cookies() ?? [];
+        if (hasA1(cookies)) return cookies;
+        task.logger?.warn("[XhsLogin] 首次抓取缺失 a1，尝试补救……");
+        try {
+            const page = task.steelBrowserContext?.pages?.()[0];
+            if (page) {
+                await page.goto("https://www.xiaohongshu.com", {
+                    waitUntil: "domcontentloaded",
+                    timeout: 15000
+                });
+                for(let i = 0; i < 10; i++){
+                    cookies = await task.steelBrowserContext?.cookies() ?? [];
+                    if (hasA1(cookies)) {
+                        task.logger?.info(`[XhsLogin] a1 补救成功，第 ${i + 1} 次轮询命中`);
+                        return cookies;
+                    }
+                    await new Promise((resolve)=>setTimeout(resolve, 500));
+                }
+            }
+        } catch (err) {
+            task.logger?.warn("[XhsLogin] a1 补救访问主站失败", err);
+        }
+        cookies = await task.steelBrowserContext?.cookies() ?? [];
+        return cookies;
+    }
     const xiaohongshuLogin_rpa_server_rpaServer = async (task, params)=>{
         const updateTaskState = task.taskStageStore?.update?.bind(task.taskStageStore, task.taskId || "");
         const reporter = task.reportService?.reportLoginStatus ?? (()=>Promise.resolve());
@@ -43654,21 +43752,29 @@ var __webpack_exports__ = {};
                     };
                 }
             case types_ExecutionState.SUCCESS:
-                await updateTaskState?.({
-                    state: types_TaskState.SUCCESS,
-                    result: {
-                        cookie: JSON.stringify(await task.steelBrowserContext?.cookies()),
-                        userInfo: userInfo
-                    }
-                });
-                return {
-                    code: 0,
-                    message: "成功",
-                    data: {
-                        cookie: JSON.stringify(await task.steelBrowserContext?.cookies()),
-                        userInfo
-                    }
-                };
+                {
+                    const cookies = await collectCookiesWithA1(task);
+                    const hasA1 = cookies.some((c)=>"a1" === c.name && !!c.value);
+                    if (!hasA1) task.logger?.warn("[XhsLogin] 登录成功但缺失关键 cookie a1，后续检测可能失败", {
+                        cookieNames: cookies.map((c)=>c.name)
+                    });
+                    const cookieStr = JSON.stringify(cookies);
+                    await updateTaskState?.({
+                        state: types_TaskState.SUCCESS,
+                        result: {
+                            cookie: cookieStr,
+                            userInfo: userInfo
+                        }
+                    });
+                    return {
+                        code: 0,
+                        message: "成功",
+                        data: {
+                            cookie: cookieStr,
+                            userInfo
+                        }
+                    };
+                }
             default:
                 return {
                     code: 500,
@@ -43869,6 +43975,14 @@ var __webpack_exports__ = {};
             const fileName = getFilenameFromUrl(url);
             const localUrl = await downloadImage(url, external_node_path_default().join(tmpCachePath, fileName));
             const fileBuffer = external_node_fs_default().readFileSync(localUrl);
+            let width = 0;
+            let height = 0;
+            try {
+                const dimensions = imageSize(fileBuffer);
+                width = dimensions.width ?? 0;
+                height = dimensions.height ?? 0;
+            } catch  {}
+            const originSize = fileBuffer.byteLength / 1024;
             const MAX_RETRIES = uploadInfos.length;
             let attempt = 0;
             while(attempt < MAX_RETRIES){
@@ -43890,7 +44004,10 @@ var __webpack_exports__ = {};
                     });
                     return {
                         ossFileId,
-                        ossToken
+                        ossToken,
+                        width,
+                        height,
+                        originSize
                     };
                 } catch (error) {
                     attempt++;
@@ -43898,7 +44015,10 @@ var __webpack_exports__ = {};
             }
             return {
                 ossFileId: "",
-                ossToken: ""
+                ossToken: "",
+                width,
+                height,
+                originSize
             };
         };
         const coverInfos = await Promise.all(params.banners.map((it, idx)=>uploadFile(it, idx)));
@@ -43963,8 +44083,16 @@ var __webpack_exports__ = {};
             },
             image_info: {
                 images: coverInfos.map((it)=>({
-                        extra_info_json: '{"mimeType":"image/png"}',
+                        extra_info_json: JSON.stringify({
+                            mimeType: "image/png",
+                            image_metadata: {
+                                bg_color: "",
+                                origin_size: it.originSize
+                            }
+                        }),
                         file_id: it.ossFileId,
+                        width: it.width,
+                        height: it.height,
                         metadata: {
                             source: -1
                         },