@iflyrpa/actions 4.0.0-beta.1 → 4.0.0-beta.12

package/dist/index.js

@@ -5489,7 +5489,7 @@ var __webpack_exports__ = {};
     });
     const package_json_namespaceObject = require("@iflyrpa/share/package.json");
     var package_json_default = /*#__PURE__*/ __webpack_require__.n(package_json_namespaceObject);
-    var package_namespaceObject = JSON.parse('{"i8":"3.0.5-beta.0"}');
+    var package_namespaceObject = JSON.parse('{"i8":"4.0.0-beta.11"}');
     const share_namespaceObject = require("@iflyrpa/share");
     const external_node_fs_namespaceObject = require("node:fs");
     var external_node_fs_default = /*#__PURE__*/ __webpack_require__.n(external_node_fs_namespaceObject);
@@ -5692,7 +5692,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);
                     }
@@ -11896,16 +11896,35 @@ var __webpack_exports__ = {};
         }, "微信账号有效性检测完成！");
     };
     const XhsSessionCheck = async (_task, params)=>{
+        const logger = _task.logger;
+        const startedAt = Date.now();
         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) return {
-            code: 414,
-            message: "账号数据异常，请重新绑定账号后重试。",
-            data: check
-        };
+        if (!a1Cookie) {
+            logger?.warn("[XhsSessionCheck] 缺失关键 cookie a1，提前返回", {
+                accountId: params.accountId,
+                cookieNames
+            });
+            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"
@@ -11933,6 +11952,7 @@ var __webpack_exports__ = {};
             return acc;
         }, {});
         const loginBaseXsHeader = sessionCheck_xsEncrypt.signHeadersGet(loginBasePath, recordCookie, "xhs-pc-web", null);
+        const baseInfoStart = Date.now();
         const _baseInfo = http.api({
             method: "get",
             baseURL: "https://creator.xiaohongshu.com",
@@ -11942,7 +11962,28 @@ var __webpack_exports__ = {};
             retries: 3,
             retryDelay: 20,
             timeout: 3000
-        }).catch((e)=>e.data);
+        }).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;
+        }).catch((e)=>{
+            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
+            });
+            return e.data;
+        });
+        const webSessionStart = Date.now();
         const _web_session = http.api({
             method: "get",
             url: "https://edith.xiaohongshu.com/api/sns/web/unread_count"
@@ -11950,6 +11991,26 @@ var __webpack_exports__ = {};
             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;
         });
         const [baseInfo, web_session] = await Promise.all([
             _baseInfo,
@@ -11957,8 +12018,18 @@ var __webpack_exports__ = {};
         ]);
         if (baseInfo?.code === 0) check.isValidSession = true;
         if (0 === web_session.code) check.isValidWebSession = true;
-        baseInfo?.code, web_session.code;
+        const _isSuccess = 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 (0, share_namespaceObject.success)(check, message);
     };
     const BjhSessionCheck = async (_task, params)=>{
@@ -14492,7 +14563,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;
@@ -14519,38 +14593,116 @@ var __webpack_exports__ = {};
             });
             return (0, share_namespaceObject.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 (0, share_namespaceObject.response)(414, "安全参数 webProtectData 不完整，请重新获取后重试", "");
+            }
+        } catch (error) {
+            task.logger.error(`解析 webProtectData 失败: ${error}`);
+            return (0, share_namespaceObject.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 (0, share_namespaceObject.response)(414, "安全参数 ec_privateKey 缺失，请重新获取后重试", "");
+            }
+        } catch (error) {
+            task.logger.error(`解析 ec_privateKey 失败: ${error}`);
+            return (0, share_namespaceObject.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 (0, share_namespaceObject.response)(414, "安全参数 certificate 缺失，请重新获取后重试", "");
+            }
+        } catch (error) {
+            task.logger.error(`解析 certificate 失败: ${error}`);
+            return (0, share_namespaceObject.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 (0, share_namespaceObject.response)(414, "安全参数 bdTicketGuardClientData 生成失败，请重新获取后重试", "");
+            }
+        } catch (error) {
+            task.logger.error(`生成 bdTicketGuardClientData 失败: ${error}`);
+            return (0, share_namespaceObject.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 (0, share_namespaceObject.response)(414, "安全参数 a_bogus 生成失败，请重试", "");
+            }
+            task.logger.info(`a_bogus 生成成功: ${aBogus.substring(0, 20)}...`);
+        } catch (error) {
+            task.logger.error(`生成 a_bogus 失败: ${error}`);
+            return (0, share_namespaceObject.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 (0, share_namespaceObject.response)(414, "安全参数 csrfToken 生成失败，请重试", "");
+            }
+            task.logger.info(`csrfToken 生成成功: ${csrfToken.substring(0, 20)}...`);
+        } catch (error) {
+            task.logger.error(`生成 csrfToken 失败: ${error}`);
+            return (0, share_namespaceObject.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 (0, share_namespaceObject.response)(414, "安全参数 sessionDtrait 生成异常，请重试", "");
+        }
         task.logger.info("发布数据", {
             data: JSON.stringify(publishData)
         });
@@ -14595,19 +14747,28 @@ var __webpack_exports__ = {};
         task.logger.info("========== api调用完成 ==========");
         task.logger.info(`decision值: ${JSON.stringify(decision)}, needsVerification(decision): ${needsVerification(decision)}`);
         if (needsVerification(decision)) {
+            const details = [
+                publishResult.status_msg,
+                decision?.verify_title,
+                decision?.verify_desc
+            ].filter(Boolean).join(" ");
+            const message = `图文发布失败，原因：${details}${task.debug ? ` ${http.proxyInfo}` : ""}`;
             task.logger.warn(`TaskId：${task.taskId}，检测到需要验证，准备返回验证信息`);
-            await updateTaskState?.({
-                state: share_namespaceObject.TaskState.SUCCESS,
+            let decisionObj = {};
+            if (decision) decisionObj = decision;
+            const mockData = {
+                state: share_namespaceObject.TaskState.FAILED,
+                error: message,
                 result: {
-                    response: decision
+                    ...decisionObj,
+                    data: decision,
+                    uploadedImgList: JSON.stringify(publishData.item.common.images)
                 }
-            });
-            task.logger.info("返回验证响应: code=0, message=操作成功");
+            };
+            await updateTaskState?.(mockData);
             return {
                 code: 0,
-                data: {
-                    result: decision
-                },
+                data: mockData,
                 message: "操作成功"
             };
         }
@@ -14629,10 +14790,13 @@ var __webpack_exports__ = {};
         const message = `图文发布${isSuccess ? "成功" : `失败，原因：${publishResult.status_msg} ${decision?.verify_title} ${decision?.verify_desc}`}${task.debug ? ` ${http.proxyInfo}` : ""}`;
         const data = isSuccess ? publishResult.item_id || "" : "";
         if (!isSuccess) {
+            let decisionObj = {};
+            if (decision) decisionObj = decision;
             await updateTaskState?.({
                 state: share_namespaceObject.TaskState.FAILED,
                 error: message,
                 result: {
+                    ...decisionObj,
                     data: decision,
                     uploadedImgList: JSON.stringify(publishData.item.common.images)
                 }
@@ -15307,15 +15471,41 @@ var __webpack_exports__ = {};
         }
         task.logger?.info("准备发布...");
         await page.waitForTimeout(1000);
-        const response = await new Promise((resolve, reject)=>{
+        const result = await new Promise((resolve, reject)=>{
             const handleResponse = async (res)=>{
                 if (res.url().includes("/web/api/media/aweme/create_v2")) {
                     task.logger?.info("匹配到发布接口响应");
+                    let decision = null;
+                    try {
+                        const headers = await res.allHeaders();
+                        decision = parseVerifyPassportDecision(headers["x-tt-verify-passport-decision"]);
+                    } catch (error) {
+                        task.logger?.warn(`解析验证决策头失败: ${error}`);
+                    }
                     const jsonResponse = await res.json();
                     task.logger?.info(`发布接口响应数据: ${JSON.stringify(jsonResponse)}`);
                     page.off("response", handleResponse);
-                    if (jsonResponse?.status_code === 0) resolve(jsonResponse?.data?.item_id || jsonResponse?.item_id || "");
-                    else reject(new Error(jsonResponse?.status_msg || "发布失败"));
+                    if (needsVerification(decision)) {
+                        task.logger?.warn("检测到需要二次验证，文章未真正发布");
+                        resolve({
+                            itemId: "",
+                            decision
+                        });
+                        return;
+                    }
+                    if (jsonResponse?.status_code !== 0) {
+                        reject(new Error(jsonResponse?.status_msg || "发布失败"));
+                        return;
+                    }
+                    const itemId = jsonResponse?.data?.item_id || jsonResponse?.item_id || "";
+                    if (!itemId) {
+                        reject(new Error(jsonResponse?.status_msg || "发布异常：未返回作品ID，文章可能未真正发布"));
+                        return;
+                    }
+                    resolve({
+                        itemId,
+                        decision: null
+                    });
                 }
             };
             page.on("response", handleResponse);
@@ -15337,20 +15527,42 @@ var __webpack_exports__ = {};
             await page.close();
             return null;
         });
-        if (!response && "" !== response) return {
+        if (!result) return {
             code: 414,
             message: "发布失败",
             data: ""
         };
-        task.logger?.info(`✓ 发布成功，item_id: ${response}`);
+        if (needsVerification(result.decision)) {
+            const decision = result.decision;
+            const details = [
+                decision?.verify_title,
+                decision?.verify_desc
+            ].filter(Boolean).join(" ");
+            const message = `发布失败，需要二次验证${details ? `：${details}` : ""}`;
+            task.logger?.warn(message);
+            await updateTaskState?.({
+                state: share_namespaceObject.TaskState.FAILED,
+                error: message,
+                result: {
+                    data: decision
+                }
+            });
+            await page.close();
+            return {
+                code: 414,
+                message,
+                data: ""
+            };
+        }
+        task.logger?.info(`✓ 发布成功，item_id: ${result.itemId}`);
         await updateTaskState?.({
             state: share_namespaceObject.TaskState.SUCCESS,
             result: {
-                response
+                response: result.itemId
             }
         });
         await page.close();
-        return (0, share_namespaceObject.success)(response);
+        return (0, share_namespaceObject.success)(result.itemId);
     };
     const DouyinPublishParamsSchema = ActionCommonParamsSchema.extend({
         title: schemas_string(),
@@ -16130,26 +16342,26 @@ var __webpack_exports__ = {};
         const http = new Http({
             headers: {
                 cookie: params.cookies.map((it)=>`${it.name}=${it.value}`).join(";"),
-                referer: "https://mp.toutiao.com/profile_v4/graphic/publish"
+                referer: "https://mp.toutiao.com/profile_v4/graphic/publish",
+                "user-agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/124.0.0.0 Safari/537.36"
+            }
+        });
+        const totalData = await http.api({
+            method: "get",
+            url: "https://mp.toutiao.com/mp/fe_api/home/merge_v2",
+            params: {
+                app_id: 1231
+            }
+        });
+        await new Promise((r)=>setTimeout(r, 1000));
+        const contentDataYesterday = await http.api({
+            method: "get",
+            url: "https://mp.toutiao.com/mp/agw/statistic/v2/content_stat",
+            params: {
+                type: 0,
+                app_id: 1231
             }
         });
-        const [totalData, contentDataYesterday] = await Promise.all([
-            http.api({
-                method: "get",
-                url: "https://mp.toutiao.com/mp/fe_api/home/merge_v2",
-                params: {
-                    app_id: 1231
-                }
-            }),
-            http.api({
-                method: "get",
-                url: "https://mp.toutiao.com/mp/agw/statistic/v2/content_stat",
-                params: {
-                    type: 0,
-                    app_id: 1231
-                }
-            })
-        ]);
         const isSuccess = !!(totalData?.data?.statistic && contentDataYesterday?.author_stat);
         if (!isSuccess || !totalData?.data || !contentDataYesterday?.author_stat) return types_errorResponse(totalData?.message || contentDataYesterday?.message || "头条号数据获取失败，请检查Cookie是否有效", 414);
         const ttData = {
@@ -20326,8 +20538,10 @@ var __webpack_exports__ = {};
             tuwen_wtt_trans_flag: params.settingInfo?.toutiaoTransWtt ? "2" : "0",
             info_source: sourceData,
             ...location ? {
-                city: location.label,
-                city_code: location.value
+                manual_selected_city: JSON.stringify({
+                    city: location.label,
+                    city_code: location.value
+                })
             } : null,
             ...params.settingInfo?.toutiaoCollectionId ? {
                 want_join_collection_id: params.settingInfo.toutiaoCollectionId
@@ -20377,6 +20591,12 @@ var __webpack_exports__ = {};
             claim_exclusive: toutiaoExclusive ? toutiaoExclusive : toutiaoOriginal?.includes("exclusive") ? 1 : 0
         };
         task._timerRecord.PrePublish = Date.now();
+        task.logger.info(`[toutiaoPublish] ${"draft" === params.saveType ? "同步草稿" : "发布文章"}参数`, {
+            saveType: params.saveType,
+            title: params.title,
+            extra: extraData,
+            publishData
+        });
         const msToken = params.cookies.find((it)=>"msToken" === it.name)?.value;
         let publishOption = {};
         if (msToken) {
@@ -21572,8 +21792,8 @@ var __webpack_exports__ = {};
             headers
         });
         const proxyHttp = new Http(...args);
-        proxyHttp.addResponseInterceptor((response)=>{
-            const responseData = response.data;
+        const baseRespFinder = (response)=>{
+            const responseData = response?.data;
             const msgType = "draft" === params.saveType ? "同步" : "发布";
             if (response && responseData?.base_resp && 0 !== responseData.base_resp.ret && !ignoreErrno.includes(responseData.base_resp.ret)) {
                 const errmsg = weixinPublish_mock_errnoMap[responseData.base_resp.ret] || response.config.defaultErrorMsg || responseData.base_resp.err_msg || `文章${msgType}异常，请稍后重试。`;
@@ -21583,7 +21803,9 @@ var __webpack_exports__ = {};
                     data: responseData
                 };
             }
-        });
+        };
+        http.addResponseInterceptor(baseRespFinder);
+        proxyHttp.addResponseInterceptor(baseRespFinder);
         await http.api({
             method: "get",
             url: "https://mp.weixin.qq.com/cgi-bin/appmsgpublish",