@iflyrpa/actions 4.0.9 → 4.1.0-beta.0

package/dist/index.js

@@ -1,5 +1,5 @@
 
-!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="4505f4f9-b586-5fae-8a9f-3ce0ceb72967")}catch(e){}}();
+!function(){try{var e="undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof globalThis?globalThis:"undefined"!=typeof self?self:{},n=(new e.Error).stack;n&&(e._sentryDebugIds=e._sentryDebugIds||{},e._sentryDebugIds[n]="4653233b-4a56-52c6-8a3b-2a28934c66cb")}catch(e){}}();
 var __webpack_modules__ = {
     "./src/utils/XhsXsCommonEnc.js": function(module) {
         var encrypt_lookup = [
@@ -4366,6 +4366,7 @@ var __webpack_exports__ = {};
         SessionCheckResultSchema: ()=>SessionCheckResultSchema,
         DouyinGetCommentReplyListParamsSchema: ()=>DouyinGetCommentReplyListParamsSchema,
         DouyinCreateCommentReplyParamsSchema: ()=>DouyinCreateCommentReplyParamsSchema,
+        ShipinhaoPublishVideoParamsSchema: ()=>ShipinhaoPublishVideoParamsSchema,
         DouyinGetHotParamsSchema: ()=>DouyinGetHotParamsSchema,
         DouyinGetMusicParamsSchema: ()=>DouyinGetMusicParamsSchema,
         FetchArticlesDataSchema: ()=>FetchArticlesDataSchema,
@@ -4402,9 +4403,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 = {
-        i8: "4.0.9"
-    };
+    var package_namespaceObject = JSON.parse('{"i8":"4.1.0-beta.0"}');
     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);
@@ -4420,6 +4419,124 @@ var __webpack_exports__ = {};
     var external_node_crypto_default = /*#__PURE__*/ __webpack_require__.n(external_node_crypto_namespaceObject);
     const external_axios_namespaceObject = require("axios");
     var external_axios_default = /*#__PURE__*/ __webpack_require__.n(external_axios_namespaceObject);
+    const USER_MESSAGE = {
+        PROXY_UNAVAILABLE: "代理暂时不可用，请稍后重试或使用本地IP",
+        NETWORK_ERROR: "网络异常，请稍后重试",
+        SYSTEM_ERROR: "系统异常，请稍后重试或联系客服",
+        PUBLISH_NETWORK: "发布失败，网络不稳定，请稍后重试",
+        DOUYIN_ACCOUNT_FETCH_FAILED: "抖音数据获取失败，请稍后重试",
+        SHIPINHAO_ACCOUNT_FETCH_FAILED: "视频号数据获取失败，请稍后重试",
+        DOUYIN_POST_FETCH_FAILED: "抖音作品数据获取失败，请稍后重试",
+        SHIPINHAO_POST_FETCH_FAILED: "视频号作品数据获取失败，请稍后重试",
+        BJH_POST_FETCH_FAILED: "百家号作品数据获取失败，请稍后重试",
+        TT_POST_FETCH_FAILED: "头条号作品数据获取失败，请稍后重试",
+        QRCODE_FETCH_FAILED: "认证二维码获取失败，请稍后重试",
+        IMAGE_UPLOAD_FAILED: "图片上传失败，请稍后重试或联系客服"
+    };
+    const NETWORK_CODES = [
+        500,
+        502,
+        503,
+        504
+    ];
+    function classifyPublishError(handledError) {
+        const { code } = handledError;
+        const isProxyRequest = handledError.extra?.isProxyRequest === true;
+        if (!NETWORK_CODES.includes(code) && 599 !== code) return null;
+        const category = 599 === code || isProxyRequest ? "代理错误" : "网络错误";
+        return {
+            category,
+            userMessage: USER_MESSAGE.PUBLISH_NETWORK
+        };
+    }
+    const RPA_ERROR_WEBHOOK_URL = "https://open.xfchat.iflytek.com/open-apis/bot/v2/hook/d202c0dc-5af5-40bc-83ed-abc677caa4a5";
+    const ALARM_THROTTLE_MS = 60000;
+    const lastSentAt = new Map();
+    const postFeishuWebhook = (webhookUrl, payload)=>external_axios_default().post(webhookUrl, payload, {
+            headers: {
+                "Content-Type": "application/json"
+            },
+            timeout: 10000
+        });
+    const buildFeishuPostMessage = (report)=>{
+        const content = [
+            [
+                {
+                    tag: "text",
+                    text: `平台：${report.platform || "未知平台"}`
+                }
+            ],
+            [
+                {
+                    tag: "text",
+                    text: `错误信息：${report.msg || "未知错误信息"}`
+                }
+            ],
+            [
+                {
+                    tag: "text",
+                    text: `错误类型：${report.errorType || "未知错误类型"}`
+                }
+            ],
+            [
+                {
+                    tag: "text",
+                    text: `阶段：${report.stage || "未知阶段"}`
+                }
+            ],
+            [
+                {
+                    tag: "text",
+                    text: `等级：${report.level}`
+                }
+            ],
+            [
+                {
+                    tag: "text",
+                    text: `来源：${report.source}`
+                }
+            ]
+        ];
+        if (void 0 !== report.code && null !== report.code) content.push([
+            {
+                tag: "text",
+                text: `接口错误码：${report.code}`
+            }
+        ]);
+        if (report.url) content.push([
+            {
+                tag: "text",
+                text: `地址：${report.url}`
+            }
+        ]);
+        if ("alarm" === report.level) content.push([
+            {
+                tag: "at",
+                user_id: "all"
+            }
+        ]);
+        return {
+            msg_type: "post",
+            content: {
+                post: {
+                    zh_cn: {
+                        title: report.title || "RPA异常",
+                        content
+                    }
+                }
+            }
+        };
+    };
+    const reportFeishuAlarm = (report)=>{
+        try {
+            const key = `${report.platform}|${report.source}|${report.errorType}|${report.code ?? ""}`;
+            const now = Date.now();
+            const last = lastSentAt.get(key);
+            if (last && now - last < ALARM_THROTTLE_MS) return;
+            lastSentAt.set(key, now);
+            postFeishuWebhook(RPA_ERROR_WEBHOOK_URL, buildFeishuPostMessage(report)).catch(()=>{});
+        } catch  {}
+    };
     const external_socks_proxy_agent_namespaceObject = require("socks-proxy-agent");
     const PROXY_CREDENTIALS = [
         {
@@ -4522,9 +4639,20 @@ var __webpack_exports__ = {};
             url: "https://fetdev.iflysec.com/ip-pool/pool/eip/proxy",
             data: params
         }).catch((err)=>{
+            reportFeishuAlarm({
+                level: "alarm",
+                platform: "ip-pool",
+                source: "proxy",
+                stage: "POST /ip-pool/pool/eip/proxy",
+                errorType: "PROXY_REQUEST_FAILED",
+                code: err?.code,
+                msg: `请求代理失败：${err.message}，区域：${addr ?? "-"}，AccountId：${accountId ?? "-"}`,
+                url: "https://fetdev.iflysec.com/ip-pool/pool/eip/proxy",
+                title: "代理异常"
+            });
             throw {
                 code: 414,
-                message: `请求代理失败：${err.message}`,
+                message: USER_MESSAGE.PROXY_UNAVAILABLE,
                 data: {}
             };
         });
@@ -4544,12 +4672,53 @@ var __webpack_exports__ = {};
         } : null;
         return proxyAgent;
     }
+    const ALARM_STATUS = new Set([
+        401,
+        403,
+        429,
+        461,
+        471
+    ]);
+    const HTTP_STATUS_MESSAGE = {
+        400: "请求参数错误，请检查参数格式是否正确！",
+        401: "登录状态已失效，请重新登录后重试！",
+        403: "没有访问权限，账号可能受限或签名已失效！",
+        404: "请求的资源不存在，请检查接口地址！",
+        405: "请求方法不被允许，请检查接口调用方式！",
+        406: "服务端无法返回可接受的内容格式！",
+        407: "代理需要身份验证，请检查代理配置！",
+        408: "请求超时，请检查网络连接！",
+        409: "请求冲突，资源状态已变更，请刷新后重试！",
+        410: "请求的资源已被移除！",
+        412: "请求前置条件不满足，请刷新后重试！",
+        413: "提交内容过大，请压缩或分批后重试！",
+        414: "请求地址过长，请检查参数！",
+        415: "不支持的内容类型，请检查请求格式！",
+        422: "请求内容校验失败，请检查参数内容！",
+        423: "资源已被锁定，请稍后重试！",
+        429: "请求过于频繁，请稍后重试！",
+        431: "请求头过大，请清理 Cookie 后重试！",
+        451: "内容不合规或因法律原因被拒绝！",
+        461: "账号可能受限，请在网页上完成验证后重试！",
+        471: "账号可能受限，请在网页上完成验证后重试！",
+        500: "服务器内部错误，请稍后重试！",
+        501: "服务端不支持该请求，请稍后重试！",
+        502: "网关错误，请稍后重试！",
+        503: "服务暂时不可用，请稍后重试！",
+        504: "网关超时，请稍后重试！",
+        507: "服务端存储空间不足，请稍后重试！",
+        509: "服务带宽超限，请稍后重试！",
+        520: "服务端返回未知错误，请稍后重试！",
+        521: "源站拒绝连接，请稍后重试！",
+        522: "源站连接超时，请稍后重试！",
+        524: "源站响应超时，请稍后重试！"
+    };
     class Http {
         static handleApiError(error) {
             if (error && "object" == typeof error && "code" in error && "message" in error) return error;
             return {
                 code: 500,
-                message: error instanceof Error ? error.message : "未知错误",
+                message: USER_MESSAGE.SYSTEM_ERROR,
                 data: error
             };
         }
@@ -4604,6 +4773,18 @@ var __webpack_exports__ = {};
                     const verifyDecision = error.response?.headers?.["x-tt-verify-passport-decision"];
                     if (verifyDecision) this.logger?.warn(`[403 验证决策] x-tt-verify-passport-decision: ${verifyDecision}`);
                 }
+                if (error.response?.status === 461 || error.response?.status === 471) {
+                    const h = error.response?.headers ?? {};
+                    const pick = (name)=>h[name] ?? h[name.toLowerCase()];
+                    this.logger?.warn(`[${error.response.status} 风控验证] URL: ${error.config?.url} Verifytype: ${pick("Verifytype") ?? "-"} Verifyuuid: ${pick("Verifyuuid") ?? "-"} Verifybiz: ${pick("Verifybiz") ?? "-"}`);
+                    this.logger?.warn(`[${error.response.status} 响应头] ${JSON.stringify(h)}`);
+                    errorResponse.extra = {
+                        ...errorResponse.extra,
+                        verifyType: pick("Verifytype"),
+                        verifyUuid: pick("Verifyuuid"),
+                        verifyBiz: pick("Verifybiz")
+                    };
+                }
                 if (error.response?.data) {
                     if ("object" == typeof error.response.data) {
                         const serverError = error.response.data;
@@ -4634,11 +4815,17 @@ var __webpack_exports__ = {};
                             _message = "DNS 查询超时，请稍后重试！";
                             break;
                         case "ERR_BAD_REQUEST":
-                            _message = "请求出现错误，请检查请求参数！";
-                            break;
+                            {
+                                const status = error.response?.status;
+                                _message = status && HTTP_STATUS_MESSAGE[status] || `请求失败，状态码${status ?? "unknown"}！`;
+                                break;
+                            }
                         case "ERR_BAD_RESPONSE":
-                            _message = `服务器响应异常 (${error.response?.status ?? "unknown"})，请稍后重试！`;
-                            break;
+                            {
+                                const status = error.response?.status;
+                                _message = status && HTTP_STATUS_MESSAGE[status] || `服务器响应异常 (${status ?? "unknown"})，请稍后重试！`;
+                                break;
+                            }
                         case "ERR_CANCELED":
                             errorResponse.code = 414;
                             _message = "请求连接超时，请稍候重试！";
@@ -4649,11 +4836,14 @@ var __webpack_exports__ = {};
                             }
                             break;
                         default:
-                            this.logger?.debug(`未处理的网络错误代码: ${error.code} ${error.message}`, {
-                                errorString: stringifyError(error)
-                            });
-                            _message = `网络错误: ${error.message}`;
-                            break;
+                            {
+                                this.logger?.debug(`未处理的网络错误代码: ${error.code} ${error.message}`, {
+                                    errorString: stringifyError(error)
+                                });
+                                const status = error.response?.status;
+                                _message = status && HTTP_STATUS_MESSAGE[status] || USER_MESSAGE.NETWORK_ERROR;
+                                break;
+                            }
                     }
                 }
                 if (error.code && !error.response?.data) errorResponse.message = _message || errorResponse.message;
@@ -4663,29 +4853,51 @@ var __webpack_exports__ = {};
                     errorResponse.message = message;
                 }
                 if (error.message.includes("Proxy connection ended")) errorResponse.message = "所在区域代理连接超时，请更换区域或稍后重试！";
+                const status = error.response?.status;
+                reportFeishuAlarm({
+                    level: status && ALARM_STATUS.has(status) ? "alarm" : "warning",
+                    platform: this.platform || "unknown",
+                    source: "http",
+                    stage: `${(error.config?.method || "get").toUpperCase()} ${error.config?.url || "-"}`,
+                    errorType: status ? `HTTP_${status}` : error.code || "NETWORK_ERROR",
+                    code: errorResponse.code,
+                    msg: errorResponse.message,
+                    url: error.config?.url,
+                    title: "RPA接口异常"
+                });
                 throw errorResponse;
             });
         }
         async api(config, options) {
             const retries = options?.retries ?? 0;
             const retryDelay = options?.retryDelay ?? 500;
-            const reqTimeout = options?.timeout ?? 30000;
+            const reqTimeout = options?.timeout ?? 60000;
+            const externalSignal = options?.signal;
             let agent;
             const sessionRt = async (Rtimes)=>{
                 try {
                     this.proxyInfo = agent ? `${agent.ip}:${agent.port}` : void 0;
                     const controller = new AbortController();
                     const timeoutId = setTimeout(()=>controller.abort(), reqTimeout + 500);
+                    const forwardAbort = ()=>controller.abort();
+                    if (externalSignal) {
+                        if (externalSignal.aborted) controller.abort();
+                        else externalSignal.addEventListener("abort", forwardAbort, {
+                            once: true
+                        });
+                    }
                     const response = await this.apiClient({
                         ...config,
                         timeout: reqTimeout,
                         signal: controller.signal,
+                        onUploadProgress: options?.onUploadProgress,
                         ...agent ? {
                             httpAgent: agent.agent,
                             httpsAgent: agent.agent
                         } : {}
                     }).finally(()=>{
                         clearTimeout(timeoutId);
+                        externalSignal?.removeEventListener("abort", forwardAbort);
                     });
                     return response.data;
                 } catch (error) {
@@ -5432,7 +5644,7 @@ var __webpack_exports__ = {};
             Number.MAX_VALUE
         ]
     };
-    function pick(schema, mask) {
+    function util_pick(schema, mask) {
         const currDef = schema._zod.def;
         const def = mergeDefs(schema._zod.def, {
             get shape () {
@@ -5802,7 +6014,7 @@ var __webpack_exports__ = {};
     const xid = /^[0-9a-vA-V]{20}$/;
     const ksuid = /^[A-Za-z0-9]{27}$/;
     const nanoid = /^[a-zA-Z0-9_-]{21}$/;
-    const duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
+    const regexes_duration = /^P(?:(\d+W)|(?!.*W)(?=\d|T\d)(\d+Y)?(\d+M)?(\d+D)?(T(?=\d)(\d+H)?(\d+M)?(\d+([.,]\d+)?S)?)?)$/;
     const guid = /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{4}-[0-9a-fA-F]{12})$/;
     const regexes_uuid = (version)=>{
         if (!version) return /^([0-9a-fA-F]{8}-[0-9a-fA-F]{4}-[1-8][0-9a-fA-F]{3}-[89abAB][0-9a-fA-F]{3}-[0-9a-fA-F]{12}|00000000-0000-0000-0000-000000000000|ffffffff-ffff-ffff-ffff-ffffffffffff)$/;
@@ -6488,7 +6700,7 @@ var __webpack_exports__ = {};
         $ZodStringFormat.init(inst, def);
     });
     const $ZodISODuration = /*@__PURE__*/ $constructor("$ZodISODuration", (inst, def)=>{
-        def.pattern ?? (def.pattern = duration);
+        def.pattern ?? (def.pattern = regexes_duration);
         $ZodStringFormat.init(inst, def);
     });
     const $ZodIPv4 = /*@__PURE__*/ $constructor("$ZodIPv4", (inst, def)=>{
@@ -8413,7 +8625,7 @@ var __webpack_exports__ = {};
         inst.extend = (incoming)=>extend(inst, incoming);
         inst.safeExtend = (incoming)=>safeExtend(inst, incoming);
         inst.merge = (other)=>merge(inst, other);
-        inst.pick = (mask)=>pick(inst, mask);
+        inst.pick = (mask)=>util_pick(inst, mask);
         inst.omit = (mask)=>omit(inst, mask);
         inst.partial = (...args)=>partial(ZodOptional, inst, args[0]);
         inst.required = (...args)=>required(ZodNonOptional, inst, args[0]);
@@ -8426,6 +8638,14 @@ var __webpack_exports__ = {};
         };
         return new ZodObject(def);
     }
+    function looseObject(shape, params) {
+        return new ZodObject({
+            type: "object",
+            shape,
+            catchall: unknown(),
+            ...normalizeParams(params)
+        });
+    }
     const ZodUnion = /*@__PURE__*/ $constructor("ZodUnion", (inst, def)=>{
         $ZodUnion.init(inst, def);
         ZodType.init(inst, def);
@@ -9124,6 +9344,13 @@ var __webpack_exports__ = {};
                     data: ""
                 };
                 const image = await (0, share_namespaceObject.downloadImage)(url, external_node_path_default().join(tmpCachePath, fileName));
+                const stats = external_node_fs_default().statSync(image);
+                const maxSize = 5242880;
+                if (stats.size > maxSize) throw {
+                    code: 414,
+                    message: "百家号平台：单张图片不得超过 5MB",
+                    data: ""
+                };
                 const formData = new (external_form_data_default())();
                 formData.append("org_file_name", fileName);
                 formData.append("type", "image");
@@ -12407,7 +12634,7 @@ var __webpack_exports__ = {};
             });
             const qrData = qrCodeResponse?.data;
             task.logger.info(`获取二维码响应: error_code=${qrData?.error_code}, message=${qrCodeResponse?.message}`);
-            if (qrData?.error_code !== 0) return (0, share_namespaceObject.response)(414, `获取二维码失败: error_code=${qrData?.error_code}`, "");
+            if (qrData?.error_code !== 0) return (0, share_namespaceObject.response)(414, USER_MESSAGE.QRCODE_FETCH_FAILED, "");
             return (0, share_namespaceObject.response)(0, "获取二维码成功", {
                 qrcode: qrData.qrcode,
                 token: qrData.token,
@@ -12422,7 +12649,7 @@ var __webpack_exports__ = {};
         } catch (err) {
             const msg = err instanceof Error ? err.message : String(err);
             task.logger.warn(`[douyinGetVerifyQrCode] 获取二维码失败: ${msg}`);
-            return (0, share_namespaceObject.response)(500, `获取二维码失败: ${msg}`, "");
+            return (0, share_namespaceObject.response)(500, USER_MESSAGE.QRCODE_FETCH_FAILED, "");
         }
     };
     const DouyinGetWorkListParamsSchema = ActionCommonParamsSchema.extend({
@@ -13261,6 +13488,11 @@ var __webpack_exports__ = {};
         }
         async getImageInfo(localPath) {
             const stats = external_node_fs_default().statSync(localPath);
+            const maxSize = 52428800;
+            if (stats.size > maxSize) {
+                external_node_path_default().basename(localPath);
+                throw new Error("抖音平台：单张图片不得超过 50MB");
+            }
             let width = 1080;
             let height = 1920;
             try {
@@ -13741,18 +13973,10 @@ var __webpack_exports__ = {};
                 });
             } catch (error) {
                 const handledError = Http.handleApiError(error);
-                const isProxyOrNetworkError = [
-                    599,
-                    500,
-                    502,
-                    503,
-                    504
-                ].includes(handledError.code);
-                if (isProxyOrNetworkError) {
-                    const isProxyRequest = handledError.extra?.isProxyRequest === true;
-                    const errorType = 599 === handledError.code || isProxyRequest ? "代理错误" : "网络错误";
-                    const message = `图文发布失败，${errorType}：${handledError.message}${task.debug ? ` ${http.proxyInfo}` : ""}`;
-                    task.logger.error(`[douyinPublish] ${errorType}，直接返回: ${message}`, stringifyError(handledError));
+                const classified = classifyPublishError(handledError);
+                if (classified) {
+                    const message = `${classified.userMessage}${task.debug ? ` ${http.proxyInfo}` : ""}`;
+                    task.logger.error(`[douyinPublish] ${classified.category}，直接返回: ${handledError.message} (code=${handledError.code})`, stringifyError(handledError));
                     await updateTaskState?.({
                         state: share_namespaceObject.TaskState.FAILED,
                         error: message
@@ -15470,7 +15694,7 @@ var __webpack_exports__ = {};
             }
             const errMsg = error instanceof Error ? error.message : String(error);
             _task.logger.error(`抖音账号数据获取失败: ${errMsg}`);
-            return types_errorResponse(errMsg || "抖音账号数据获取失败");
+            return types_errorResponse(USER_MESSAGE.DOUYIN_ACCOUNT_FETCH_FAILED);
         }
     }
     async function getShipinhaoData(_task, params) {
@@ -15601,7 +15825,7 @@ var __webpack_exports__ = {};
             }
             const errMsg = error instanceof Error ? error.message : String(error);
             _task.logger.error(`视频号账号数据获取失败: ${errMsg}`);
-            return types_errorResponse(errMsg || "视频号账号数据获取失败");
+            return types_errorResponse(USER_MESSAGE.SHIPINHAO_ACCOUNT_FETCH_FAILED);
         }
     }
     async function getToutiaoData(_task, params) {
@@ -16042,7 +16266,9 @@ var __webpack_exports__ = {};
                 } : null
             }, "百家号文章数据获取成功");
         } catch (error) {
-            return searchPublishInfo_types_errorResponse(error instanceof Error ? error.message : "百家号文章数据获取失败");
+            const errMsg = error instanceof Error ? error.message : String(error);
+            _task.logger.error(`百家号文章数据获取失败: ${errMsg}`);
+            return searchPublishInfo_types_errorResponse(USER_MESSAGE.BJH_POST_FETCH_FAILED);
         }
     }
     async function handleDouyinData(_task, params) {
@@ -16137,7 +16363,9 @@ var __webpack_exports__ = {};
                 } : null
             }, "抖音数据获取成功");
         } catch (error) {
-            return searchPublishInfo_types_errorResponse(error instanceof Error ? error.message : "抖音数据获取失败");
+            const errMsg = error instanceof Error ? error.message : String(error);
+            _task.logger.error(`抖音作品数据获取失败: ${errMsg}`);
+            return searchPublishInfo_types_errorResponse(USER_MESSAGE.DOUYIN_POST_FETCH_FAILED);
         }
     }
     async function handleShipinhaoData(_task, params) {
@@ -16302,8 +16530,9 @@ var __webpack_exports__ = {};
             }, "视频号数据获取成功");
         } catch (error) {
             const errMsg = error instanceof Error ? error.message : String(error);
+            _task.logger.error(`视频号作品数据获取失败: ${errMsg}`);
             if (errMsg.startsWith("AUTH_ERROR:")) return searchPublishInfo_types_errorResponse("视频号数据获取失败，请检查账号状态", 414);
-            return searchPublishInfo_types_errorResponse(errMsg || "视频号数据获取失败");
+            return searchPublishInfo_types_errorResponse(USER_MESSAGE.SHIPINHAO_POST_FETCH_FAILED);
         }
     }
     async function handleToutiaoData(_task, params) {
@@ -16388,7 +16617,9 @@ var __webpack_exports__ = {};
                 } : null
             }, "头条号文章文章获取成功");
         } catch (error) {
-            return searchPublishInfo_types_errorResponse(error instanceof Error ? error.message : "头条号文章数据获取失败");
+            const errMsg = error instanceof Error ? error.message : String(error);
+            _task.logger.error(`头条号文章数据获取失败: ${errMsg}`);
+            return searchPublishInfo_types_errorResponse(USER_MESSAGE.TT_POST_FETCH_FAILED);
         }
     }
     const external_node_vm_namespaceObject = require("node:vm");
@@ -18765,18 +18996,10 @@ var __webpack_exports__ = {};
                 });
             } catch (error) {
                 const handledError = Http.handleApiError(error);
-                const isProxyOrNetworkError = [
-                    599,
-                    500,
-                    502,
-                    503,
-                    504
-                ].includes(handledError.code);
-                if (isProxyOrNetworkError) {
-                    const isProxyRequest = handledError.extra?.isProxyRequest === true;
-                    const errorType = 599 === handledError.code || isProxyRequest ? "代理错误" : "网络错误";
-                    const message = `图文发布失败，${errorType}：${handledError.message}${task.debug ? ` ${http.proxyInfo}` : ""}`;
-                    task.logger.error(`[shipinhaoPublish] ${errorType}，直接返回: ${message}`, stringifyError(handledError));
+                const classified = classifyPublishError(handledError);
+                if (classified) {
+                    const message = `${classified.userMessage}${task.debug ? ` ${http.proxyInfo}` : ""}`;
+                    task.logger.error(`[shipinhaoPublish] ${classified.category}，直接返回: ${handledError.message} (code=${handledError.code})`, stringifyError(handledError));
                     await updateTaskState?.({
                         state: share_namespaceObject.TaskState.FAILED,
                         error: message
@@ -19516,107 +19739,1747 @@ var __webpack_exports__ = {};
         if ("server" === params.actionType) return rpa_server_rpaAction_Server(task, params);
         return executeAction(shipinhaoPublish_mock_mockAction, rpa_server_rpaAction_Server)(task, params);
     };
-    const ShipinhaoSendMsgParamsSchema = ActionCommonParamsSchema.extend({
-        toUsername: schemas_string().min(1, "接收者用户名不能为空"),
-        sessionId: schemas_string().min(1, "会话ID不能为空"),
-        msgType: schemas_enum([
-            "TEXT",
-            "IMAGE"
-        ], {
-            message: "消息类型必须是 TEXT 或 IMAGE"
-        }),
-        content: schemas_string().optional(),
-        imageInfo: schemas_object({
-            pathOrUrl: schemas_string().min(1, "图片路径或URL不能为空")
-        }).optional()
-    });
-    const CHUNK_SIZE = 524288;
-    async function shipinhaoSendMsg_getUserInfo(cookieStr, http) {
-        const url = `https://channels.weixin.qq.com/cgi-bin/mmfinderassistant-bin/auth/auth_data?_rid=${rid()}`;
-        const headers = {
-            referer: "https://channels.weixin.qq.com/micro/interaction/private_msg",
-            cookie: cookieStr,
-            Origin: "https://channels.weixin.qq.com"
-        };
-        return await http.api({
-            method: "get",
-            url,
-            headers
-        }, {
-            retries: 3,
-            retryDelay: 1000,
-            timeout: 10000
+    function auth_getTimeStamp(length) {
+        return Date.now().toString().substring(0, length);
+    }
+    async function auth_getUserInfo(cookies, http) {
+        return http.api({
+            method: "post",
+            url: "https://channels.weixin.qq.com/cgi-bin/mmfinderassistant-bin/auth/auth_data",
+            data: {
+                timestamp: auth_getTimeStamp(13),
+                _log_finder_uin: "",
+                _log_finder_id: "",
+                rawKeyBuff: null,
+                pluginSessionId: null,
+                scene: 7,
+                reqScene: 7
+            },
+            headers: {
+                cookie: cookies,
+                referer: "https://channels.weixin.qq.com",
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+            },
+            defaultErrorMsg: "获取用户信息失败"
         });
     }
-    const shipinhaoSendMsg = async (_task, params)=>{
-        if (!params.sessionId) return (0, share_namespaceObject.response)(414, "sessionId 不能为空", void 0);
-        if (!params.toUsername) return (0, share_namespaceObject.response)(414, "接收者用户名不能为空", void 0);
-        if (!params.msgType) return (0, share_namespaceObject.response)(414, "消息类型不能为空", void 0);
-        if (![
-            "TEXT",
-            "IMAGE"
-        ].includes(params.msgType)) return (0, share_namespaceObject.response)(414, "消息类型必须是 TEXT 或 IMAGE", void 0);
-        if ("TEXT" === params.msgType) {
-            if (!params.content || "" === params.content.trim()) return (0, share_namespaceObject.response)(414, "消息内容不能为空", void 0);
-        }
-        if ("IMAGE" === params.msgType) {
-            if (!params.imageInfo?.pathOrUrl) return (0, share_namespaceObject.response)(414, "图片路径或URL不能为空", void 0);
+    async function auth_getUploadAuthKey(cookies, finderUsername, http) {
+        return http.api({
+            method: "post",
+            url: "https://channels.weixin.qq.com/cgi-bin/mmfinderassistant-bin/helper/helper_upload_params",
+            data: {
+                timestamp: auth_getTimeStamp(13),
+                _log_finder_id: finderUsername,
+                rawKeyBuff: null
+            },
+            headers: {
+                cookie: cookies,
+                referer: "https://channels.weixin.qq.com",
+                Accept: "application/json, text/plain, */*",
+                "Content-Type": "application/json",
+                "User-Agent": "Mozilla/5.0 (Windows NT 10.0; Win64; x64) AppleWebKit/537.36"
+            },
+            defaultErrorMsg: "获取上传认证密钥失败"
+        });
+    }
+    class ShipinhaoAuthError extends Error {
+        constructor(message, errCode){
+            super(message), this.errCode = errCode;
+            this.name = "ShipinhaoAuthError";
         }
-        if (!params.extraParam) return (0, share_namespaceObject.response)(414, "缺少 extraParam 参数", void 0);
-        if (!params.extraParam.fingerPrintDeviceId || !params.extraParam.aId || !params.extraParam.uin) return (0, share_namespaceObject.response)(414, "fingerPrintDeviceId、aId 和 uin 不能为空", void 0);
-        const cookieStr = params.cookies.map((it)=>`${it.name}=${it.value}`).join(";");
-        const headers = {
-            cookie: cookieStr,
-            referer: "https://channels.weixin.qq.com/micro/interaction/private_msg",
-            origin: "https://channels.weixin.qq.com",
-            "content-type": "application/json",
-            "finger-print-device-id": params.extraParam.fingerPrintDeviceId,
-            "x-wechat-uin": params.extraParam.uin
+    }
+    async function getShipinhaoUploadAuth(cookies, http) {
+        const userInfo = await auth_getUserInfo(cookies, http);
+        if (0 !== userInfo.errCode || !userInfo.data?.finderUser) {
+            const isLoginExpired = 300333 === userInfo.errCode || 300334 === userInfo.errCode;
+            throw new ShipinhaoAuthError(isLoginExpired ? "登录失效" : userInfo.errMsg || "获取用户信息失败", userInfo.errCode || 500);
+        }
+        const finderUsername = userInfo.data.finderUser.finderUsername;
+        const authKeyResponse = await auth_getUploadAuthKey(cookies, finderUsername, http);
+        if (0 !== authKeyResponse.errCode || !authKeyResponse.data?.authKey) throw new ShipinhaoAuthError(`获取上传认证参数失败: ${authKeyResponse.errMsg}`, authKeyResponse.errCode || 500);
+        const uin = authKeyResponse.data.uin;
+        if (!uin) throw new ShipinhaoAuthError("获取用户 uin 失败", 500);
+        const videoFileType = authKeyResponse.data.videoFileType || 20302;
+        const pictureFileType = authKeyResponse.data.pictureFileType || 20304;
+        return {
+            uin,
+            authKey: authKeyResponse.data.authKey,
+            finderUsername,
+            videoFileType,
+            pictureFileType
         };
-        const http = new Http({
-            headers
+    }
+    const MENTION_TEXT_SUFFIX = "\u0020";
+    const MENTION_XML_SUFFIX = "\u2005";
+    function payload_buildDescription(params) {
+        let description = params.description || "";
+        for (const topic of params.topics || [])description += `#${topic}`;
+        for (const user of params.mentionedUsers || [])description += `@${user.nickname}${MENTION_TEXT_SUFFIX}`;
+        return description;
+    }
+    function buildMentionedUser(mentionedUsers) {
+        return (mentionedUsers || []).map((user)=>({
+                nickname: `${user.nickname}${MENTION_TEXT_SUFFIX}`
+            }));
+    }
+    function payload_buildTopicXml(params) {
+        const values = [];
+        let atIndex = null;
+        if (params.description) values.push(`<![CDATA[${params.description}]]>`);
+        for (const topic of params.topics || [])values.push(`<topic><![CDATA[#${topic}#]]></topic>`);
+        for (const user of params.mentionedUsers || []){
+            if (null === atIndex) atIndex = values.length;
+            values.push(`<![CDATA[@${user.nickname}${MENTION_XML_SUFFIX}]]>`);
+        }
+        let xml = "<finder>";
+        xml += "<version>1</version>";
+        xml += `<valuecount>${values.length}</valuecount>`;
+        xml += `<style><at>${atIndex ?? ""}</at></style>`;
+        values.forEach((value, index)=>{
+            xml += `<value${index}>${value}</value${index}>`;
         });
-        const urlParams = new URLSearchParams({
-            _aid: params.extraParam.aId,
-            _rid: rid(),
-            _pageUrl: "https://channels.weixin.qq.com/micro/interaction/private_msg"
-        }).toString();
-        const generateCliMsgId = ()=>"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (s)=>{
-                const t = 16 * Math.random() | 0;
-                return ("x" === s ? t : 3 & t | 8).toString(16);
+        xml += "</finder>";
+        return xml;
+    }
+    function payload_buildLocation(location) {
+        if (!location) return {
+            latitude: 0,
+            longitude: 0,
+            city: "",
+            poiName: "",
+            address: "",
+            poiClassifyId: ""
+        };
+        return {
+            latitude: location.latitude,
+            longitude: location.longitude,
+            city: location.city,
+            poiName: location.poiName || "",
+            address: location.address || "",
+            poiClassifyId: location.poiClassifyId || ""
+        };
+    }
+    function buildTopic(params) {
+        const topic = {
+            finderTopicInfo: payload_buildTopicXml(params)
+        };
+        if (params.collection) {
+            topic.collectionId = params.collection.collectionId;
+            topic.collectionName = params.collection.collectionName;
+        }
+        return topic;
+    }
+    function buildEvent(event) {
+        if (!event) return {};
+        return {
+            eventTopicId: event.eventTopicId,
+            eventName: event.eventName,
+            eventCreatorNickname: event.eventCreatorNickname || ""
+        };
+    }
+    function buildExtReading(link) {
+        if (!link) return {
+            link: "",
+            title: "",
+            urlType: 1
+        };
+        return {
+            link: link.link.replace(/[\s\u200b]/g, ""),
+            title: link.title,
+            urlType: link.urlType ?? 1
+        };
+    }
+    function buildTagInfo(tagInfo, tagKey) {
+        return {
+            ...tagInfo,
+            tagKey
+        };
+    }
+    const CHUNK_SIZE = 8388608;
+    const UPLOAD_STAGE_TIMEOUT = 180000;
+    const DEFAULT_TUNING = {
+        metaTimeout: UPLOAD_STAGE_TIMEOUT,
+        partTimeout: UPLOAD_STAGE_TIMEOUT,
+        partRetries: 3,
+        completeTimeout: UPLOAD_STAGE_TIMEOUT
+    };
+    async function uploader_uploadFile(opts) {
+        const { filePath, fileType, uin, authKey, http, logger, tuning } = opts;
+        const stat = external_node_fs_default().statSync(filePath);
+        const fileSize = stat.size;
+        const fileName = filePath.split(/[\\/]/).pop() || "file";
+        const metaTimeout = tuning?.metaTimeout ?? DEFAULT_TUNING.metaTimeout;
+        const partTimeout = tuning?.partTimeout ?? DEFAULT_TUNING.partTimeout;
+        const partRetries = tuning?.partRetries ?? DEFAULT_TUNING.partRetries;
+        const completeTimeout = tuning?.completeTimeout ?? DEFAULT_TUNING.completeTimeout;
+        logger?.info(`开始上传: ${fileName} (${fileSize} B, filetype=${fileType})`);
+        logger?.info(`上传超时策略: 单片 ${partTimeout / 1000}s（重试 ${partRetries} 次）、合并 ${completeTimeout / 1000}s`);
+        const fileMd5 = await computeFileMd5(filePath);
+        const taskId = generateTaskId(fileName, fileSize, fileMd5);
+        const baseUrl = "https://finderassistancea.video.qq.com";
+        const headers = {
+            Authorization: authKey
+        };
+        const xArgs = `apptype=251&filetype=${fileType}&weixinnum=${uin}&filekey=${encodeURIComponent(fileName)}&filesize=${fileSize}&taskid=${taskId}&scene=2`;
+        const chunkCount = Math.ceil(fileSize / CHUNK_SIZE);
+        const blockPartLength = [];
+        for(let i = 0; i < chunkCount; i++)blockPartLength.push(Math.min((i + 1) * CHUNK_SIZE, fileSize));
+        logger?.info(`申请 UploadID: ${chunkCount} 片`);
+        const applyRes = await http.api({
+            method: "PUT",
+            url: `${baseUrl}/applyuploaddfs`,
+            headers: {
+                ...headers,
+                "X-Arguments": xArgs
+            },
+            data: {
+                BlockSum: chunkCount,
+                BlockPartLength: blockPartLength
+            }
+        }, {
+            timeout: metaTimeout,
+            retries: 2,
+            retryDelay: 2000
+        });
+        if (!applyRes.UploadID && !applyRes.ListPartsResult) throw new Error("申请 UploadID 失败: " + JSON.stringify(applyRes));
+        let uploadId = applyRes.UploadID;
+        const uploadedParts = new Set();
+        if (applyRes.ListPartsResult) {
+            logger?.info("检测到已上传分片，执行续传");
+            const parts = Array.isArray(applyRes.ListPartsResult.Part) ? applyRes.ListPartsResult.Part : applyRes.ListPartsResult.Part ? [
+                applyRes.ListPartsResult.Part
+            ] : [];
+            for (const p of parts)uploadedParts.add(p.PartNumber);
+            const retryRes = await http.api({
+                method: "PUT",
+                url: `${baseUrl}/applyuploaddfs`,
+                headers: {
+                    ...headers,
+                    "X-Arguments": xArgs
+                },
+                data: {
+                    BlockSum: chunkCount,
+                    BlockPartLength: blockPartLength
+                }
+            }, {
+                timeout: metaTimeout,
+                retries: 2,
+                retryDelay: 2000
             });
-        let fromUsername = params.extraParam.finderUserName;
-        if (!fromUsername) {
-            _task.logger.info("未提供 finderUserName，尝试获取用户信息");
-            const userInfoRes = await shipinhaoSendMsg_getUserInfo(cookieStr, http);
-            if (!userInfoRes.data?.finderUser?.finderUsername) return (0, share_namespaceObject.response)(userInfoRes.errCode || -1, userInfoRes.errMsg || "获取用户信息失败", {});
-            fromUsername = userInfoRes.data.finderUser.finderUsername;
-            _task.logger.info(`获取到用户名: ${fromUsername}`);
+            uploadId = retryRes.UploadID;
+            if (!uploadId) throw new Error("续传获取 UploadID 失败");
         }
-        let imgMsg;
-        if ("IMAGE" === params.msgType) {
-            let imageBuffer;
-            const imagePath = params.imageInfo.pathOrUrl;
-            try {
-                if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
-                    const resp = await external_axios_default().get(imagePath, {
-                        responseType: "arraybuffer"
-                    });
-                    imageBuffer = Buffer.from(resp.data);
-                } else {
-                    const filePath = imagePath.startsWith("file://") ? imagePath.slice(7) : imagePath;
-                    imageBuffer = Buffer.from(await external_node_fs_default().promises.readFile(filePath));
+        const partInfo = [];
+        const fd = external_node_fs_default().openSync(filePath, "r");
+        try {
+            for(let i = 0; i < chunkCount; i++){
+                const partNumber = i + 1;
+                if (uploadedParts.has(partNumber)) {
+                    const existing = applyRes.ListPartsResult.Part.find((p)=>p.PartNumber === partNumber);
+                    if (existing) {
+                        partInfo.push({
+                            PartNumber: partNumber,
+                            ETag: existing.ETag
+                        });
+                        logger?.info(`分片 ${partNumber}/${chunkCount} 已存在，跳过`);
+                        continue;
+                    }
                 }
-            } catch (err) {
-                return (0, share_namespaceObject.response)(414, `读取图片失败: ${err instanceof Error ? err.message : String(err)}`, void 0);
+                const start = i * CHUNK_SIZE;
+                const end = Math.min(start + CHUNK_SIZE, fileSize);
+                const chunkSize = end - start;
+                const chunk = Buffer.alloc(chunkSize);
+                external_node_fs_default().readSync(fd, chunk, 0, chunkSize, start);
+                const chunkMd5 = external_node_crypto_default().createHash("md5").update(chunk).digest("hex");
+                const partStart = Date.now();
+                await http.api({
+                    method: "PUT",
+                    url: `${baseUrl}/uploadpartdfs?PartNumber=${partNumber}&UploadID=${encodeURIComponent(uploadId)}`,
+                    headers: {
+                        ...headers,
+                        "X-Arguments": xArgs.replace(/scene=2/, "scene=0"),
+                        "Content-MD5": chunkMd5
+                    },
+                    data: chunk
+                }, {
+                    timeout: partTimeout,
+                    retries: partRetries,
+                    retryDelay: 2000
+                });
+                const partElapsed = Date.now() - partStart;
+                const throughput = Math.round(chunkSize / (partElapsed / 1000));
+                partInfo.push({
+                    PartNumber: partNumber,
+                    ETag: `"${chunkMd5}"`
+                });
+                logger?.info(`分片 ${partNumber}/${chunkCount} 完成 (${chunkSize} B, ${partElapsed}ms, ${Math.round(throughput / 1024)}KB/s)`);
             }
-            const md5 = (0, external_node_crypto_namespaceObject.createHash)("md5").update(imageBuffer).digest("hex");
+        } finally{
+            external_node_fs_default().closeSync(fd);
+        }
+        logger?.info("合并分片...");
+        const completeRes = await http.api({
+            method: "POST",
+            url: `${baseUrl}/completepartuploaddfs?UploadID=${encodeURIComponent(uploadId)}`,
+            headers: {
+                ...headers,
+                "X-Arguments": xArgs
+            },
+            data: {
+                TransFlag: "0_0",
+                PartInfo: partInfo
+            }
+        }, {
+            timeout: completeTimeout,
+            retries: 1,
+            retryDelay: 3000
+        });
+        if (!completeRes.DownloadURL) throw new Error("合并分片失败: " + JSON.stringify(completeRes));
+        logger?.info("上传成功");
+        return {
+            downloadUrl: completeRes.DownloadURL,
+            md5: fileMd5,
+            fileSize
+        };
+    }
+    async function computeFileMd5(filePath) {
+        return new Promise((resolve, reject)=>{
+            const hash = external_node_crypto_default().createHash("md5");
+            const stream = external_node_fs_default().createReadStream(filePath);
+            stream.on("data", (chunk)=>hash.update(chunk));
+            stream.on("end", ()=>resolve(hash.digest("hex")));
+            stream.on("error", reject);
+        });
+    }
+    function generateTaskId(fileName, fileSize, fileMd5) {
+        const input = `${fileName}-${fileSize}-${fileMd5}`;
+        return external_node_crypto_default().createHash("md5").update(input).digest("hex").slice(0, 32);
+    }
+    const MAX_METADATA_BOX_SIZE = 268435456;
+    function readBoxHeader(fd, offset, limit) {
+        if (offset + 8 > limit) return null;
+        const head = Buffer.alloc(16);
+        const read = external_node_fs_default().readSync(fd, head, 0, 16, offset);
+        if (read < 8) return null;
+        let size = head.readUInt32BE(0);
+        const type = head.toString("latin1", 4, 8);
+        let headerSize = 8;
+        if (1 === size) {
+            if (read < 16) return null;
+            size = head.readUInt32BE(8) * 2 ** 32 + head.readUInt32BE(12);
+            headerSize = 16;
+        } else if (0 === size) size = limit - offset;
+        if (size < headerSize || offset + size > limit) return null;
+        return {
+            type,
+            size,
+            headerSize
+        };
+    }
+    function parseVideoMeta(filePath) {
+        let fd;
+        let fileSize;
+        try {
+            fd = external_node_fs_default().openSync(filePath, "r");
+        } catch  {
+            return null;
+        }
+        try {
+            fileSize = external_node_fs_default().fstatSync(fd).size;
+            const state = {
+                movie: null,
+                tracks: [],
+                trexDefaults: new Map(),
+                fragmentDurations: new Map(),
+                trafTrackId: 0,
+                trafDefaultSampleDuration: 0
+            };
+            let offset = 0;
+            while(offset + 8 <= fileSize){
+                const header = readBoxHeader(fd, offset, fileSize);
+                if (!header) break;
+                if ("moov" === header.type || "moof" === header.type) {
+                    const bodyLength = header.size - header.headerSize;
+                    if (bodyLength > 0 && bodyLength <= MAX_METADATA_BOX_SIZE) {
+                        const body = Buffer.alloc(bodyLength);
+                        const read = external_node_fs_default().readSync(fd, body, 0, bodyLength, offset + header.headerSize);
+                        state.trafTrackId = 0;
+                        state.trafDefaultSampleDuration = 0;
+                        walkBoxes(body.subarray(0, read), 0, read, state);
+                    }
+                }
+                offset += header.size;
+            }
+            const { movie, tracks } = state;
+            const video = tracks.find((t)=>"vide" === t.handler) || tracks.find((t)=>t.width > 0 && t.height > 0);
+            if (!video) return null;
+            let { width, height } = video;
+            if (90 === video.rotation || 270 === video.rotation) [width, height] = [
+                height,
+                width
+            ];
+            return {
+                width: Math.round(width),
+                height: Math.round(height),
+                duration: resolveDuration(movie, video, state.fragmentDurations),
+                rotation: video.rotation,
+                fileSize,
+                codec: video.codec
+            };
+        } catch  {
+            return null;
+        } finally{
+            try {
+                external_node_fs_default().closeSync(fd);
+            } catch  {}
+        }
+    }
+    function walkBoxes(buf, start, end, state) {
+        let off = start;
+        while(off + 8 <= end){
+            let size = buf.readUInt32BE(off);
+            const type = buf.toString("latin1", off + 4, off + 8);
+            let headerSize = 8;
+            if (1 === size) {
+                if (off + 16 > end) break;
+                const hi = buf.readUInt32BE(off + 8);
+                const lo = buf.readUInt32BE(off + 12);
+                size = hi * 2 ** 32 + lo;
+                headerSize = 16;
+            } else if (0 === size) size = end - off;
+            if (size < headerSize || off + size > end) break;
+            const bodyStart = off + headerSize;
+            const bodyEnd = off + size;
+            switch(type){
+                case "trak":
+                case "mdia":
+                case "minf":
+                case "stbl":
+                case "mvex":
+                case "traf":
+                    walkBoxes(buf, bodyStart, bodyEnd, state);
+                    break;
+                case "mvhd":
+                    state.movie = parseMvhd(buf, bodyStart, bodyEnd);
+                    break;
+                case "tkhd":
+                    state.tracks.push({
+                        ...parseTkhd(buf, bodyStart, bodyEnd),
+                        handler: null,
+                        codec: null,
+                        timescale: 0,
+                        mdhdDuration: 0,
+                        sttsDuration: 0
+                    });
+                    break;
+                case "mdhd":
+                    {
+                        const mdhd = parseMvhd(buf, bodyStart, bodyEnd);
+                        if (mdhd && state.tracks.length) {
+                            const track = state.tracks[state.tracks.length - 1];
+                            track.timescale = mdhd.timescale;
+                            track.mdhdDuration = mdhd.duration;
+                        }
+                        break;
+                    }
+                case "hdlr":
+                    if (bodyEnd - bodyStart >= 12 && state.tracks.length) state.tracks[state.tracks.length - 1].handler = buf.toString("latin1", bodyStart + 8, bodyStart + 12);
+                    break;
+                case "stsd":
+                    {
+                        const codec = parseStsdCodec(buf, bodyStart, bodyEnd);
+                        if (codec && state.tracks.length) state.tracks[state.tracks.length - 1].codec = codec;
+                        break;
+                    }
+                case "stts":
+                    if (state.tracks.length) state.tracks[state.tracks.length - 1].sttsDuration = parseSttsDuration(buf, bodyStart, bodyEnd);
+                    break;
+                case "trex":
+                    if (bodyStart + 20 > bodyEnd) break;
+                    state.trexDefaults.set(buf.readUInt32BE(bodyStart + 4), buf.readUInt32BE(bodyStart + 12));
+                    break;
+                case "tfhd":
+                    {
+                        const tfhd = parseTfhd(buf, bodyStart, bodyEnd);
+                        state.trafTrackId = tfhd.trackId;
+                        state.trafDefaultSampleDuration = tfhd.defaultSampleDuration || state.trexDefaults.get(tfhd.trackId) || 0;
+                        break;
+                    }
+                case "trun":
+                    {
+                        const duration = parseTrunDuration(buf, bodyStart, bodyEnd, state.trafDefaultSampleDuration);
+                        state.fragmentDurations.set(state.trafTrackId, (state.fragmentDurations.get(state.trafTrackId) || 0) + duration);
+                        break;
+                    }
+            }
+            off += size;
+        }
+    }
+    const UNKNOWN_DURATION_32 = 0xffffffff;
+    function isUsableDuration(duration) {
+        return duration > 0 && duration !== UNKNOWN_DURATION_32;
+    }
+    function resolveDuration(movie, video, fragmentDurations) {
+        if (movie && movie.timescale && isUsableDuration(movie.duration)) return movie.duration / movie.timescale;
+        if (video.timescale) {
+            if (isUsableDuration(video.mdhdDuration)) return video.mdhdDuration / video.timescale;
+            if (video.sttsDuration > 0) return video.sttsDuration / video.timescale;
+            const fragment = fragmentDurations.get(video.trackId) ?? (1 === fragmentDurations.size ? [
+                ...fragmentDurations.values()
+            ][0] : 0);
+            if (fragment > 0) return fragment / video.timescale;
+        }
+        return 0;
+    }
+    function parseSttsDuration(buf, start, end) {
+        if (start + 8 > end) return 0;
+        const entryCount = buf.readUInt32BE(start + 4);
+        let total = 0;
+        for(let i = 0; i < entryCount; i++){
+            const off = start + 8 + 8 * i;
+            if (off + 8 > end) break;
+            total += buf.readUInt32BE(off) * buf.readUInt32BE(off + 4);
+        }
+        return total;
+    }
+    function parseTfhd(buf, start, end) {
+        if (start + 8 > end) return {
+            trackId: 0,
+            defaultSampleDuration: 0
+        };
+        const flags = buf.readUIntBE(start + 1, 3);
+        const trackId = buf.readUInt32BE(start + 4);
+        let off = start + 8;
+        if (0x000001 & flags) off += 8;
+        if (0x000002 & flags) off += 4;
+        if (0x000008 & flags && off + 4 <= end) return {
+            trackId,
+            defaultSampleDuration: buf.readUInt32BE(off)
+        };
+        return {
+            trackId,
+            defaultSampleDuration: 0
+        };
+    }
+    function parseTrunDuration(buf, start, end, defaultSampleDuration) {
+        if (start + 8 > end) return 0;
+        const flags = buf.readUIntBE(start + 1, 3);
+        const sampleCount = buf.readUInt32BE(start + 4);
+        let off = start + 8;
+        if (0x000001 & flags) off += 4;
+        if (0x000004 & flags) off += 4;
+        const hasDuration = (0x000100 & flags) !== 0;
+        if (!hasDuration) return sampleCount * defaultSampleDuration;
+        const entrySize = 4 + ((0x000200 & flags) !== 0 ? 4 : 0) + ((0x000400 & flags) !== 0 ? 4 : 0) + ((0x000800 & flags) !== 0 ? 4 : 0);
+        let total = 0;
+        for(let i = 0; i < sampleCount; i++){
+            const entryOff = off + i * entrySize;
+            if (entryOff + 4 > end) break;
+            total += buf.readUInt32BE(entryOff);
+        }
+        return total;
+    }
+    function parseStsdCodec(buf, start, end) {
+        if (start + 16 > end) return null;
+        if (0 === buf.readUInt32BE(start + 4)) return null;
+        return buf.toString("latin1", start + 12, start + 16).toLowerCase();
+    }
+    function parseMvhd(buf, start, end) {
+        const version = buf.readUInt8(start);
+        if (1 === version) {
+            if (start + 28 > end) return null;
+            const timescale = buf.readUInt32BE(start + 20);
+            const hi = buf.readUInt32BE(start + 24);
+            const lo = buf.readUInt32BE(start + 28);
+            return {
+                timescale,
+                duration: hi * 2 ** 32 + lo
+            };
+        }
+        if (start + 20 > end) return null;
+        return {
+            timescale: buf.readUInt32BE(start + 12),
+            duration: buf.readUInt32BE(start + 16)
+        };
+    }
+    function parseTkhd(buf, start, end) {
+        const version = buf.readUInt8(start);
+        const afterDuration = 1 === version ? 36 : 24;
+        const matrixOff = start + afterDuration + 16;
+        const whOff = matrixOff + 36;
+        const trackIdOff = start + (1 === version ? 20 : 12);
+        const trackId = trackIdOff + 4 <= end ? buf.readUInt32BE(trackIdOff) : 0;
+        if (whOff + 8 > end) return {
+            trackId,
+            width: 0,
+            height: 0,
+            rotation: 0
+        };
+        const width = buf.readUInt32BE(whOff) / 65536;
+        const height = buf.readUInt32BE(whOff + 4) / 65536;
+        const a = buf.readInt32BE(matrixOff) / 65536;
+        const b = buf.readInt32BE(matrixOff + 4) / 65536;
+        let rotation = 0;
+        if (Math.abs(a) < 0.01 && Math.abs(b - 1) < 0.01) rotation = 90;
+        else if (Math.abs(a + 1) < 0.01 && Math.abs(b) < 0.01) rotation = 180;
+        else if (Math.abs(a) < 0.01 && Math.abs(b + 1) < 0.01) rotation = 270;
+        return {
+            trackId,
+            width,
+            height,
+            rotation
+        };
+    }
+    function parseVideoCodec(filePath) {
+        return parseVideoMeta(filePath)?.codec ?? null;
+    }
+    function buildVideoMetaFromParams(filePath, metadata) {
+        return {
+            width: Math.round(metadata.width),
+            height: Math.round(metadata.height),
+            duration: metadata.duration,
+            rotation: 0,
+            fileSize: metadata.fileSize,
+            codec: parseVideoCodec(filePath)
+        };
+    }
+    const MAX_DURATION_SECONDS = 28800;
+    const MAX_FILE_SIZE = 21474836480;
+    const ALLOWED_EXTENSIONS = [
+        ".mp4"
+    ];
+    const ALLOWED_CODECS = [
+        "avc1",
+        "avc3"
+    ];
+    const MIN_TITLE_LENGTH = 6;
+    const MAX_TITLE_LENGTH = 16;
+    function formatFileSize(bytes) {
+        if (bytes < 1048576) return `${(bytes / 1024).toFixed(2)} KB`;
+        if (bytes < 1073741824) return `${(bytes / 1024 / 1024).toFixed(2)} MB`;
+        return `${(bytes / 1024 / 1024 / 1024).toFixed(2)} GB`;
+    }
+    function formatDuration(seconds) {
+        const total = Math.round(seconds);
+        const h = Math.floor(total / 3600);
+        const m = Math.floor(total % 3600 / 60);
+        const s = total % 60;
+        if (h > 0) return `${h}小时${m}分${s}秒`;
+        if (m > 0) return `${m}分${s}秒`;
+        return `${s}秒`;
+    }
+    function validateShipinhaoVideo(filePath, meta) {
+        const fileName = external_node_path_default().basename(filePath);
+        const ext = external_node_path_default().extname(fileName).toLowerCase();
+        if (!ALLOWED_EXTENSIONS.includes(ext)) return `视频格式不支持：${fileName}。视频号仅支持 MP4/H.264 格式，请转换后重试。`;
+        if (meta.duration > MAX_DURATION_SECONDS) return `视频时长超过限制：${fileName}（${formatDuration(meta.duration)}）。视频号视频时长不能超过 8 小时，请剪辑后重试。`;
+        if (meta.fileSize > MAX_FILE_SIZE) return `视频大小超过限制：${fileName}（${formatFileSize(meta.fileSize)}）。视频号视频不能超过 20GB，请压缩后重试。`;
+        if (meta.codec && !ALLOWED_CODECS.includes(meta.codec)) return `视频编码不支持：${fileName}（${meta.codec}）。视频号仅支持 H.264 编码，请转码后重试。`;
+        return null;
+    }
+    function validateShipinhaoTitle(title) {
+        if (void 0 === title) return null;
+        const trimmed = title.trim();
+        if ("" === trimmed) return null;
+        const length = [
+            ...trimmed
+        ].length;
+        if (length < MIN_TITLE_LENGTH || length > MAX_TITLE_LENGTH) return `视频号标题需要在 ${MIN_TITLE_LENGTH}-${MAX_TITLE_LENGTH} 个字符之间，当前 ${length} 个字符，请调整后重试。`;
+        return null;
+    }
+    const POST_CREATE_PAGE_URL = "https://channels.weixin.qq.com/micro/content/post/create";
+    const MICRO_CONTENT_BASE = "https://channels.weixin.qq.com/micro/content/cgi-bin/mmfinderassistant-bin";
+    function resolveClientContext(params, fallbackUin) {
+        const extra = params.extraParam || {};
+        const deviceIdCookie = params.cookies.find((c)=>"device_id" === c.name || "finger_print_device_id" === c.name)?.value;
+        return {
+            aId: "string" == typeof extra.aId ? extra.aId : "",
+            fingerPrintDeviceId: "string" == typeof extra.fingerPrintDeviceId ? extra.fingerPrintDeviceId : deviceIdCookie || "",
+            uin: "string" == typeof extra.uin ? extra.uin : String(fallbackUin)
+        };
+    }
+    function buildPublishHeaders(cookieString, client) {
+        const headers = {
+            cookie: cookieString,
+            referer: POST_CREATE_PAGE_URL,
+            origin: "https://channels.weixin.qq.com",
+            "content-type": "application/json"
+        };
+        if (client.fingerPrintDeviceId) headers["finger-print-device-id"] = client.fingerPrintDeviceId;
+        if (client.uin) headers["x-wechat-uin"] = client.uin;
+        return headers;
+    }
+    function buildPublishQuery(client) {
+        const query = {
+            _rid: rid(),
+            _pageUrl: POST_CREATE_PAGE_URL
+        };
+        if (client.aId) query._aid = client.aId;
+        return query;
+    }
+    function buildCommonBody(finderUsername) {
+        return {
+            timestamp: String(Date.now()),
+            _log_finder_uin: "",
+            _log_finder_id: finderUsername,
+            rawKeyBuff: "",
+            pluginSessionId: null,
+            scene: 7,
+            reqScene: 7
+        };
+    }
+    async function getTraceKey(auth, client, http, logger) {
+        logger.info("[getTraceKey] 开始获取 traceKey...");
+        const res = await http.api({
+            method: "POST",
+            url: `${MICRO_CONTENT_BASE}/post/get-finder-post-trace-key`,
+            params: buildPublishQuery(client),
+            data: {
+                objectId: "",
+                ...buildCommonBody(auth.finderUsername)
+            },
+            defaultErrorMsg: "获取 traceKey 失败"
+        });
+        if (0 !== res.errCode || !res.data?.traceKey) {
+            logger.error("[getTraceKey] 获取失败:", JSON.stringify(res));
+            throw new Error(`获取 traceKey 失败: ${JSON.stringify(res)}`);
+        }
+        logger.info(`[getTraceKey] 获取成功: ${res.data.traceKey}`);
+        return res.data.traceKey;
+    }
+    async function getObjectTagKey(auth, client, http, logger) {
+        logger.info("[getObjectTagKey] 获取内容声明 tagKey...");
+        try {
+            const res = await http.api({
+                method: "POST",
+                url: `${MICRO_CONTENT_BASE}/post/finder_get_object_tag_list`,
+                params: buildPublishQuery(client),
+                data: {
+                    source: 1,
+                    ...buildCommonBody(auth.finderUsername)
+                },
+                defaultErrorMsg: "获取内容声明标注失败"
+            });
+            if (0 !== res.errCode || !res.data?.tagKey) {
+                logger.warn(`[getObjectTagKey] 未取到 tagKey: ${JSON.stringify(res)}`);
+                return null;
+            }
+            logger.info(`[getObjectTagKey] tagKey: ${res.data.tagKey}`);
+            return res.data.tagKey;
+        } catch (error) {
+            logger.warn(`[getObjectTagKey] 获取 tagKey 异常: ${stringifyError(error)}`);
+            return null;
+        }
+    }
+    async function submitAndPollTranscode(opts) {
+        const { videoUrl, videoMeta, traceKey, uploadStartTime, uploadEndTime, finderUsername, client, http, logger } = opts;
+        logger.info("[submitAndPollTranscode] 开始提交转码任务...");
+        const finderUrl = videoUrl.includes("wxapp.tc.qq.com") ? `https://finder.video.qq.com${videoUrl.split("qq.com")[1]}` : videoUrl;
+        logger.info(`[submitAndPollTranscode] 视频尺寸: ${videoMeta.width}x${videoMeta.height}, 时长: ${videoMeta.duration}s`);
+        const submitRes = await http.api({
+            method: "POST",
+            url: `${MICRO_CONTENT_BASE}/post/post_clip_video`,
+            params: buildPublishQuery(client),
+            data: {
+                url: finderUrl,
+                timeStart: 0,
+                cropDuration: 0,
+                height: videoMeta.height,
+                width: videoMeta.width,
+                x: 0,
+                y: 0,
+                clipOriginVideoInfo: {
+                    width: videoMeta.width,
+                    height: videoMeta.height,
+                    duration: videoMeta.duration,
+                    fileSize: videoMeta.fileSize
+                },
+                traceInfo: {
+                    traceKey,
+                    uploadCdnStart: uploadStartTime,
+                    uploadCdnEnd: uploadEndTime
+                },
+                targetWidth: videoMeta.width,
+                targetHeight: videoMeta.height,
+                type: 4,
+                useAstraThumbCover: 1,
+                ...buildCommonBody(finderUsername)
+            },
+            defaultErrorMsg: "提交转码失败"
+        });
+        if (0 !== submitRes.errCode || !submitRes.data?.clipKey) {
+            logger.error("[submitAndPollTranscode] 提交转码失败:", JSON.stringify(submitRes));
+            throw new Error(`提交转码失败: ${JSON.stringify(submitRes)}`);
+        }
+        const { clipKey, draftId } = submitRes.data;
+        logger.info(`[submitAndPollTranscode] 转码任务已提交，clipKey: ${clipKey}, draftId: ${draftId}`);
+        const pollInterval = 5000;
+        const pollBudget = Math.min(1800000, 300000 + 1000 * Math.ceil(1.5 * videoMeta.duration));
+        const maxPolls = Math.ceil(pollBudget / pollInterval);
+        let pollCount = 0;
+        logger.info(`[submitAndPollTranscode] 开始轮询转码结果，最多 ${maxPolls} 次（${Math.round(pollBudget / 1000)}s），间隔 ${pollInterval / 1000}s`);
+        while(pollCount < maxPolls){
+            await sleep(pollInterval);
+            pollCount++;
+            const pollRes = await http.api({
+                method: "POST",
+                url: `${MICRO_CONTENT_BASE}/post/post_clip_video_result`,
+                params: buildPublishQuery(client),
+                data: {
+                    clipKey,
+                    draftId,
+                    ...buildCommonBody(finderUsername)
+                },
+                defaultErrorMsg: "转码轮询失败"
+            }, {
+                timeout: 60000,
+                retries: 2,
+                retryDelay: 3000
+            });
+            if (0 !== pollRes.errCode) {
+                logger.error(`[submitAndPollTranscode] 转码轮询失败 (poll ${pollCount}):`, JSON.stringify(pollRes));
+                throw new Error(`转码轮询失败 (poll ${pollCount}): ${JSON.stringify(pollRes)}`);
+            }
+            const { flag, url, width, height, duration, md5, fileSize } = pollRes.data || {};
+            logger.info(`[submitAndPollTranscode] 轮询第 ${pollCount} 次，flag=${flag}`);
+            if (1 === flag) {
+                if (!url || !width || !height || !duration || !md5 || !fileSize) {
+                    logger.error("[submitAndPollTranscode] 转码完成但返回数据不完整:", JSON.stringify(pollRes.data));
+                    throw new Error(`转码完成但返回数据不完整: ${JSON.stringify(pollRes.data)}`);
+                }
+                logger.info(`[submitAndPollTranscode] 转码完成! 用时: ${pollCount * pollInterval / 1000}s`);
+                logger.info(`[submitAndPollTranscode] 视频信息: ${width}x${height}, 时长: ${duration}s, 大小: ${fileSize}`);
+                return {
+                    clipKey,
+                    url,
+                    width,
+                    height,
+                    duration,
+                    md5,
+                    fileSize
+                };
+            }
+            if (2 === flag) logger.info(`[submitAndPollTranscode] 转码中... (${pollCount}/${maxPolls})`);
+            else {
+                logger.error(`[submitAndPollTranscode] 转码失败，未知 flag=${flag}:`, JSON.stringify(pollRes.data));
+                throw new Error(`转码失败，未知 flag=${flag}: ${JSON.stringify(pollRes.data)}`);
+            }
+        }
+        logger.error(`[submitAndPollTranscode] 转码超时，已轮询 ${maxPolls} 次，用时: ${maxPolls * pollInterval / 1000}s`);
+        throw new Error(`转码超时 (${maxPolls * pollInterval / 1000}s)`);
+    }
+    async function publishVideo(opts) {
+        const { params, auth, client, clipResult, videoUpload, coverUpload, verticalCoverUpload, videoMeta, traceKey, tagKey, uploadStartTime, uploadEndTime, proxyHttp, logger } = opts;
+        logger.info("[publishVideo] 开始构建发布请求...");
+        const toFinderUrl = (url)=>url.includes("wxapp.tc.qq.com") ? `https://finder.video.qq.com${url.split("qq.com")[1]}` : url;
+        const thumbFinderUrl = toFinderUrl(coverUpload.downloadUrl);
+        const coverFinderUrl = toFinderUrl(verticalCoverUpload.downloadUrl);
+        const md5sumUuid = external_node_crypto_default().randomUUID();
+        const description = params.description;
+        logger.info("[publishVideo] 发布参数:");
+        logger.info(`  - 短标题: ${params.title || "(无)"}`);
+        logger.info(`  - 描述: ${description.substring(0, 50)}${description.length > 50 ? "..." : ""}`);
+        logger.info(`  - 定时发布: ${params.scheduledTime ? new Date(1000 * params.scheduledTime).toLocaleString() : "立即发布"}`);
+        const objectDesc = {
+            mpTitle: "",
+            description,
+            extReading: buildExtReading(params.link),
+            mediaType: 4,
+            location: payload_buildLocation(params.location),
+            topic: buildTopic({
+                description: params.description,
+                topics: params.topics,
+                mentionedUsers: params.mentionedUsers,
+                collection: params.collection
+            }),
+            event: buildEvent(params.event),
+            mentionedUser: buildMentionedUser(params.mentionedUsers),
+            media: [
+                {
+                    url: clipResult.url,
+                    fileSize: clipResult.fileSize,
+                    thumbUrl: thumbFinderUrl,
+                    fullThumbUrl: thumbFinderUrl,
+                    coverUrl: coverFinderUrl,
+                    fullCoverUrl: coverFinderUrl,
+                    shareCoverUrl: coverFinderUrl,
+                    mediaType: 4,
+                    videoPlayLen: Math.round(clipResult.duration),
+                    width: clipResult.width,
+                    height: clipResult.height,
+                    md5sum: md5sumUuid,
+                    cardShowStyle: 2,
+                    urlCdnTaskId: clipResult.clipKey
+                }
+            ],
+            shortTitle: params.title ? [
+                {
+                    shortTitle: params.title
+                }
+            ] : [],
+            member: {}
+        };
+        const publishData = {
+            objectType: 0,
+            longitude: 0,
+            latitude: 0,
+            feedLongitude: 0,
+            feedLatitude: 0,
+            originalFlag: params.originalFlag ?? 0,
+            topics: params.topics || [],
+            isFullPost: 1,
+            handleFlag: 2,
+            videoClipTaskId: clipResult.clipKey,
+            traceInfo: {
+                traceKey,
+                uploadCdnStart: uploadStartTime,
+                uploadCdnEnd: uploadEndTime
+            },
+            objectDesc,
+            report: {
+                clipKey: clipResult.clipKey,
+                draftId: clipResult.clipKey,
+                ...buildCommonBody(auth.finderUsername),
+                height: videoMeta.height,
+                width: videoMeta.width,
+                duration: videoMeta.duration,
+                fileSize: videoUpload.fileSize,
+                uploadCost: (uploadEndTime - uploadStartTime) * 1000
+            },
+            postFlag: 0,
+            mode: 1,
+            clientid: external_node_crypto_default().randomUUID(),
+            ...buildCommonBody(auth.finderUsername)
+        };
+        if (params.scheduledTime) publishData.effectiveTime = params.scheduledTime;
+        if (params.tagInfo && tagKey) publishData.tagInfo = buildTagInfo(params.tagInfo, tagKey);
+        logger.info("[publishVideo] 开始发布视频，全部参数：" + JSON.stringify(publishData));
+        const publishRes = await proxyHttp.api({
+            method: "POST",
+            url: `${MICRO_CONTENT_BASE}/post/post_create`,
+            params: buildPublishQuery(client),
+            data: publishData,
+            defaultErrorMsg: "发布视频失败"
+        });
+        logger.info(`[publishVideo] 发布响应: errCode=${publishRes.errCode}, baseResp.errcode=${publishRes.data?.baseResp?.errcode}`);
+        return publishRes;
+    }
+    function sleep(ms) {
+        return new Promise((resolve)=>setTimeout(resolve, ms));
+    }
+    async function resolveLocalCoverPath(coverPath, label, tmpCachePath, logger) {
+        if (!/^https?:\/\//i.test(coverPath)) return coverPath;
+        const fileName = (0, share_namespaceObject.getFilenameFromUrl)(coverPath);
+        const savePath = external_node_path_default().join(tmpCachePath, `${Date.now()}-${label}-${fileName}`);
+        await (0, share_namespaceObject.downloadImage)(coverPath, savePath);
+        return savePath;
+    }
+    const shipinhaoPublishVideo_mock_mockAction = async (task, params)=>{
+        task.logger.info("[shipinhaoPublishVideo] 开始执行视频号视频发布 - Mock API 方式");
+        const updateTaskState = task.taskStageStore?.update?.bind(task.taskStageStore, task.taskId || "");
+        let currentStep = "初始化";
+        try {
+            task.logger.info(`[shipinhaoPublishVideo] 发布方式: ${params.scheduledTime ? `定时 ${new Date(1000 * params.scheduledTime).toLocaleString()}` : "立即发布"}`);
+            currentStep = "解析认证信息";
+            const cookieString = params.cookies.map((c)=>`${c.name}=${c.value}`).join("; ");
+            const http = new Http({
+                headers: {
+                    cookie: cookieString
+                }
+            });
+            currentStep = "验证发布参数";
+            if (!params.videoPath) return (0, share_namespaceObject.response)(414, "视频文件路径不能为空", "");
+            if (!params.coverPath) return (0, share_namespaceObject.response)(414, "横屏封面图片路径不能为空", "");
+            currentStep = "获取上传认证";
+            task.logger.info("[shipinhaoPublishVideo] 获取上传认证...");
+            const auth = await getShipinhaoUploadAuth(cookieString, http);
+            const client = resolveClientContext(params, auth.uin);
+            if (!client.aId) task.logger.warn("[shipinhaoPublishVideo] extraParam.aId 缺失，query 将不带 _aid");
+            if (!client.fingerPrintDeviceId) task.logger.warn("[shipinhaoPublishVideo] extraParam.fingerPrintDeviceId 缺失，请求将不带 finger-print-device-id");
+            const publishHeaders = buildPublishHeaders(cookieString, client);
+            const microHttp = new Http({
+                headers: publishHeaders
+            });
+            const args = [
+                {
+                    headers: publishHeaders
+                },
+                task.logger,
+                params.proxyLoc,
+                params.accountId,
+                "shipinhao"
+            ];
+            const proxyHttp = new Http(...args);
+            currentStep = "组装视频元数据";
+            task.logger.info("[shipinhaoPublishVideo] 组装视频元数据...");
+            const videoMeta = buildVideoMetaFromParams(params.videoPath, params.videoMetadata);
+            task.logger.info(`[shipinhaoPublishVideo] 视频: ${videoMeta.width}×${videoMeta.height}, ${videoMeta.duration.toFixed(2)}s, ${(videoMeta.fileSize / 1024 / 1024).toFixed(2)}MB, codec=${videoMeta.codec || "unknown"}`);
+            if (!videoMeta.codec) task.logger.warn("[shipinhaoPublishVideo] 未能读取视频编码格式，跳过 H.264 预检，交由服务端判断");
+            currentStep = "校验视频限制";
+            const validationError = validateShipinhaoVideo(params.videoPath, videoMeta);
+            if (validationError) {
+                task.logger.error(`[shipinhaoPublishVideo] 视频校验未通过: ${validationError}`);
+                await updateTaskState?.({
+                    state: share_namespaceObject.TaskState.FAILED,
+                    error: validationError
+                });
+                return (0, share_namespaceObject.response)(414, validationError, "");
+            }
+            task.logger.info("[shipinhaoPublishVideo] 视频校验通过");
+            currentStep = "校验标题";
+            const titleError = validateShipinhaoTitle(params.title);
+            if (titleError) {
+                task.logger.error(`[shipinhaoPublishVideo] 标题校验未通过: ${titleError}`);
+                await updateTaskState?.({
+                    state: share_namespaceObject.TaskState.FAILED,
+                    error: titleError
+                });
+                return (0, share_namespaceObject.response)(414, titleError, "");
+            }
+            currentStep = "获取 traceKey";
+            task.logger.info("[shipinhaoPublishVideo] 获取 traceKey...");
+            const traceKey = await getTraceKey(auth, client, microHttp, task.logger);
+            let tagKey = null;
+            if (params.tagInfo) {
+                currentStep = "获取内容声明 tagKey";
+                tagKey = await getObjectTagKey(auth, client, microHttp, task.logger);
+            }
+            const uploadStartTime = Math.floor(Date.now() / 1000);
+            task.logger.info(`[shipinhaoPublishVideo] 上传开始时间: ${uploadStartTime}`);
+            currentStep = "上传视频";
+            task.logger.info("[shipinhaoPublishVideo] 上传视频...");
+            task.logger.info(`[shipinhaoPublishVideo] 视频路径: ${params.videoPath}`);
+            task.logger.info(`[shipinhaoPublishVideo] 视频文件类型: ${auth.videoFileType}`);
+            const videoUpload = await uploader_uploadFile({
+                filePath: params.videoPath,
+                fileType: auth.videoFileType,
+                uin: auth.uin,
+                authKey: auth.authKey,
+                http,
+                logger: task.logger
+            });
+            task.logger.info("[shipinhaoPublishVideo] 视频上传完成");
+            const uploadEndTime = Math.floor(Date.now() / 1000);
+            task.logger.info(`[shipinhaoPublishVideo] 上传结束时间: ${uploadEndTime}, 耗时: ${uploadEndTime - uploadStartTime}s`);
+            currentStep = "上传横屏封面";
+            const localCoverPath = await resolveLocalCoverPath(params.coverPath, "横屏封面", task.getTmpPath(), task.logger);
+            task.logger.info("[shipinhaoPublishVideo] 上传横屏封面...");
+            const coverUpload = await uploader_uploadFile({
+                filePath: localCoverPath,
+                fileType: auth.pictureFileType,
+                uin: auth.uin,
+                authKey: auth.authKey,
+                http,
+                logger: task.logger
+            });
+            task.logger.info("[shipinhaoPublishVideo] 横屏封面上传完成");
+            let verticalCoverUpload = coverUpload;
+            if (params.verticalCoverPath) {
+                currentStep = "上传竖屏封面";
+                const localVerticalPath = await resolveLocalCoverPath(params.verticalCoverPath, "竖屏封面", task.getTmpPath(), task.logger);
+                task.logger.info("[shipinhaoPublishVideo] 上传竖屏封面");
+                verticalCoverUpload = await uploader_uploadFile({
+                    filePath: localVerticalPath,
+                    fileType: auth.pictureFileType,
+                    uin: auth.uin,
+                    authKey: auth.authKey,
+                    http,
+                    logger: task.logger
+                });
+                task.logger.info("[shipinhaoPublishVideo] 竖屏封面上传完成");
+            } else task.logger.info("[shipinhaoPublishVideo] 未传竖屏封面，复用横屏封面");
+            currentStep = "提交转码";
+            task.logger.info("[shipinhaoPublishVideo] 提交转码...");
+            const clipResult = await submitAndPollTranscode({
+                videoUrl: videoUpload.downloadUrl,
+                videoMeta,
+                traceKey,
+                uploadStartTime,
+                uploadEndTime,
+                finderUsername: auth.finderUsername,
+                client,
+                http: microHttp,
+                logger: task.logger
+            });
+            currentStep = "发布视频";
+            task.logger.info("[shipinhaoPublishVideo] 发布视频...");
+            task.logger.info(`[shipinhaoPublishVideo] clipKey: ${clipResult.clipKey}`);
+            let publishResult;
+            try {
+                publishResult = await publishVideo({
+                    params,
+                    auth,
+                    client,
+                    clipResult,
+                    videoUpload,
+                    coverUpload,
+                    verticalCoverUpload,
+                    videoMeta,
+                    traceKey,
+                    tagKey,
+                    uploadStartTime,
+                    uploadEndTime,
+                    proxyHttp,
+                    logger: task.logger
+                });
+            } catch (error) {
+                const handledError = Http.handleApiError(error);
+                task.logger.error(`[shipinhaoPublishVideo] 发布请求失败: ${handledError.message}`, stringifyError(handledError));
+                const classified = classifyPublishError(handledError);
+                if (classified) {
+                    const message = `${classified.userMessage}${task.debug ? ` ${http.proxyInfo}` : ""}`;
+                    task.logger.error(`[shipinhaoPublishVideo] ${classified.category}，直接返回: ${handledError.message} (code=${handledError.code})`, stringifyError(handledError));
+                    await updateTaskState?.({
+                        state: share_namespaceObject.TaskState.FAILED,
+                        error: message
+                    });
+                    return {
+                        code: 414,
+                        data: "",
+                        message
+                    };
+                }
+                throw error;
+            }
+            task.logger.info(`[shipinhaoPublishVideo] publishResult: ${JSON.stringify(publishResult)}`);
+            const resultCode = publishResult.data?.baseResp?.errcode ?? publishResult.errCode;
+            const resultMsg = publishResult.data?.baseResp?.errmsg ?? (0 === resultCode ? "发布成功" : `发布失败（errCode=${resultCode}）`);
+            if (0 === resultCode) {
+                task.logger.info("[shipinhaoPublishVideo] 发布成功");
+                task.logger.info(`[shipinhaoPublishVideo] 作品ID: ${clipResult.clipKey}`);
+                task.logger.info(`[shipinhaoPublishVideo] 视频URL: ${clipResult.url}`);
+                task.logger.info(`[shipinhaoPublishVideo] 横屏封面URL: ${coverUpload.downloadUrl}`);
+                task.logger.info(`[shipinhaoPublishVideo] 竖屏封面URL: ${verticalCoverUpload.downloadUrl}`);
+                await updateTaskState?.({
+                    state: share_namespaceObject.TaskState.SUCCESS,
+                    result: {
+                        response: resultMsg
+                    }
+                });
+                reportLogger({
+                    token: params.huiwenToken || "",
+                    enverionment: task.enverionment || "development",
+                    postId: params.articleId,
+                    eip: proxyHttp.proxyInfo,
+                    accountId: params.accountId,
+                    uid: params.uid,
+                    publishParams: {
+                        videoPath: params.videoPath,
+                        coverPath: params.coverPath,
+                        verticalCoverPath: params.verticalCoverPath,
+                        title: params.title,
+                        topics: params.topics,
+                        mentionedUsers: params.mentionedUsers,
+                        collection: params.collection,
+                        event: params.event,
+                        link: params.link,
+                        tagInfo: params.tagInfo,
+                        originalFlag: params.originalFlag,
+                        scheduledTime: params.scheduledTime
+                    },
+                    platform: "shipinhao"
+                });
+                task.logger.info("[shipinhaoPublishVideo] 日志上报完成");
+                return (0, share_namespaceObject.response)(0, "发布成功", clipResult.clipKey);
+            }
+            let errorMessage = resultMsg;
+            if (-11224 === resultCode) errorMessage = "视频号管理员完成实名且绑定手机号后才可以发表";
+            else if (300333 === resultCode || 300334 === resultCode) errorMessage = "登录失效";
+            else if (300330 === resultCode) errorMessage = "未登录";
+            else if (300002 === resultCode) errorMessage = "官方平台在校验音乐/位置/定时信息时失败了，请重新编辑后发布";
+            task.logger.error(`[shipinhaoPublishVideo] 发布失败: ${errorMessage} (errCode=${resultCode})`);
+            await updateTaskState?.({
+                state: share_namespaceObject.TaskState.FAILED,
+                error: errorMessage
+            });
+            return (0, share_namespaceObject.response)(resultCode || 414, errorMessage, "");
+        } catch (error) {
+            const handledError = Http.handleApiError(error);
+            const errorMsg = handledError.message || "发布失败，请稍后重试";
+            const errorCode = handledError.code || 414;
+            task.logger.error(`[shipinhaoPublishVideo] 发布流程异常 [${currentStep}]: ${errorMsg}`, stringifyError(error), handledError.extra);
+            task.logger.error(`[shipinhaoPublishVideo] 错误码: ${errorCode}, 当前步骤: ${currentStep}`);
+            await updateTaskState?.({
+                state: share_namespaceObject.TaskState.FAILED,
+                error: errorMsg
+            });
+            return (0, share_namespaceObject.response)(errorCode, errorMsg, "");
+        }
+    };
+    const shipinhaoPublishVideo_rpa_rpaAction = async (task, params)=>{
+        task.logger.info("开始微信视频号视频发布（RPA 模式）");
+        const videoMeta = buildVideoMetaFromParams(params.videoPath, params.videoMetadata);
+        task.logger.info(`视频: ${videoMeta.width}×${videoMeta.height}, ${videoMeta.duration.toFixed(2)}s, ${(videoMeta.fileSize / 1024 / 1024).toFixed(2)}MB, codec=${videoMeta.codec || "unknown"}`);
+        if (!videoMeta.codec) task.logger.warn("未能读取视频编码格式，跳过 H.264 预检，交由服务端判断");
+        const validationError = validateShipinhaoVideo(params.videoPath, videoMeta);
+        if (validationError) {
+            task.logger.error(`视频校验未通过: ${validationError}`);
+            return (0, share_namespaceObject.response)(414, validationError, "");
+        }
+        task.logger.info("视频校验通过");
+        const titleError = validateShipinhaoTitle(params.title);
+        if (titleError) {
+            task.logger.error(`标题校验未通过: ${titleError}`);
+            return (0, share_namespaceObject.response)(414, titleError, "");
+        }
+        const unsupported = [
+            params.verticalCoverPath && "verticalCoverPath",
+            params.collection && "collection",
+            params.originalFlag && "originalFlag",
+            params.postWithMemberZoneLink && "postWithMemberZoneLink"
+        ].filter(Boolean);
+        if (unsupported.length) task.logger.warn(`RPA 模式不支持以下参数，将被忽略: ${unsupported.join("、")}；如需生效请使用 mockApi 模式`);
+        if (params.tagInfo && 5 === params.tagInfo.tagType) {
+            const shootInfo = params.tagInfo.shootInfo;
+            if (shootInfo && (shootInfo.provinceCode || shootInfo.cityCode)) task.logger.warn("tagInfo.tagType=5 在 RPA 模式下仅支持拍摄时间和国家选择，省市选择需要使用 mockApi 模式");
+        }
+        const tmpCachePath = task.getTmpPath();
+        const page = await task.createPage({
+            url: "https://channels.weixin.qq.com/platform/post/create",
+            show: task.debug,
+            cookies: params.cookies
+        });
+        try {
+            const waitForElement = async (selector, timeout = 10000)=>{
+                try {
+                    const element = page.locator(selector);
+                    await element.waitFor({
+                        state: "visible",
+                        timeout
+                    });
+                    return element;
+                } catch  {
+                    task.logger.warn(`元素未找到: ${selector}`);
+                    return null;
+                }
+            };
+            const retryAction = async (action, maxRetries = 3, delay = 1000)=>{
+                let lastError;
+                for(let i = 0; i < maxRetries; i++)try {
+                    return await action();
+                } catch (error) {
+                    lastError = error;
+                    task.logger.warn(`重试 ${i + 1}/${maxRetries}: ${lastError.message}`);
+                    if (i < maxRetries - 1) await page.waitForTimeout(delay);
+                }
+                throw lastError;
+            };
+            task.logger.info("等待页面加载...");
+            task.logger.info("检查登录状态...");
+            if (task.debug) {
+                task.logger.info(`当前页面 URL: ${page.url()}`);
+                const title = await page.title();
+                task.logger.info(`页面标题: ${title}`);
+            }
+            try {
+                await page.waitForSelector(".post-edit-wrap", {
+                    state: "visible",
+                    timeout: 30000
+                });
+                task.logger.info("✓ 登录状态正常，找到编辑器容器");
+            } catch  {
+                task.logger.error("✗ 未找到编辑器，可能登录失效");
+                return {
+                    code: 414,
+                    message: "登录失效或页面加载异常",
+                    data: page.url()
+                };
+            }
+            task.logger.info("页面加载完成，开始填充内容");
+            task.logger.info("开始上传视频");
+            await retryAction(async ()=>{
+                const videoUploadSelectors = [
+                    '.ant-upload-btn input[type="file"][accept*="video"]',
+                    '.upload input[type="file"][accept*="video"]',
+                    'input[type="file"][accept*="video"]'
+                ];
+                let uploadInput = null;
+                if (task.debug) {
+                    const allFileInputs = await page.locator('input[type="file"]').count();
+                    task.logger.info(`页面中共找到 ${allFileInputs} 个文件上传输入框`);
+                }
+                for (const selector of videoUploadSelectors){
+                    const input = page.locator(selector);
+                    const count = await input.count();
+                    if (count > 0) {
+                        uploadInput = input.first();
+                        task.logger.info(`找到视频上传输入框: ${selector}`);
+                        break;
+                    }
+                }
+                if (!uploadInput) {
+                    task.logger.warn("未找到视频上传输入框，等待 3 秒后重试...");
+                    await page.waitForTimeout(3000);
+                    const anyFileInput = page.locator('input[type="file"]');
+                    const inputCount = await anyFileInput.count();
+                    if (inputCount > 0) {
+                        uploadInput = anyFileInput.first();
+                        task.logger.info(`找到文件输入框（共 ${inputCount} 个）`);
+                    } else {
+                        if (task.debug) {
+                            const screenshotPath = external_node_path_default().join(tmpCachePath, `upload-error-${Date.now()}.png`);
+                            await page.screenshot({
+                                path: screenshotPath,
+                                fullPage: true
+                            });
+                            task.logger.error(`未找到上传输入框，已截图保存至: ${screenshotPath}`);
+                        }
+                        throw new Error("未找到视频上传输入框");
+                    }
+                }
+                await uploadInput.setInputFiles(params.videoPath);
+                task.logger.info("视频上传成功");
+                await page.waitForTimeout(5000);
+            });
+            if (params.coverPath) {
+                task.logger.info("开始上传封面");
+                await retryAction(async ()=>{
+                    const coverUploadBtn = await waitForElement(".cover-upload-btn", 10000);
+                    if (coverUploadBtn) {
+                        const coverInput = page.locator('.cover-upload-btn input[type="file"]');
+                        await coverInput.setInputFiles(params.coverPath);
+                        task.logger.info("封面上传成功");
+                        await page.waitForTimeout(2000);
+                    }
+                });
+            }
+            const descriptionText = payload_buildDescription({
+                description: params.description,
+                topics: params.topics,
+                mentionedUsers: params.mentionedUsers
+            });
+            if (descriptionText) {
+                task.logger.info("填写视频描述");
+                await retryAction(async ()=>{
+                    const descEditor = await waitForElement(".input-editor", 10000);
+                    if (!descEditor) throw new Error("未找到描述编辑器");
+                    await descEditor.click();
+                    await page.waitForTimeout(500);
+                    await descEditor.evaluate((el)=>{
+                        el.textContent = "";
+                    });
+                    await page.waitForTimeout(300);
+                    task.logger.info("已清空编辑器内容");
+                    await descEditor.pressSequentially(descriptionText, {
+                        delay: 10
+                    });
+                    await page.waitForTimeout(500);
+                    task.logger.info("描述填写完成");
+                });
+            }
+            if (params.title) {
+                task.logger.info(`填写标题: ${params.title}`);
+                const title = params.title;
+                await retryAction(async ()=>{
+                    const titleInput = await waitForElement("#container-wrap div.form-item-body.short-title-wrap input", 10000);
+                    if (!titleInput) throw new Error("未找到标题输入框");
+                    await titleInput.click();
+                    await titleInput.clear({
+                        timeout: 3000
+                    });
+                    await titleInput.fill(title, {
+                        timeout: 5000
+                    });
+                    task.logger.info("标题填写完成");
+                });
+            }
+            if (params.location) {
+                task.logger.info(`选择地点: ${params.location.city}`);
+                const instance = page.locator(".position-display-wrap");
+                await instance.click();
+                await page.waitForTimeout(1000);
+                await page.locator(".location-filter-wrap input").fill(params.location.city);
+                await page.waitForTimeout(2000);
+                const poperInstance = page.locator(".location-filter-wrap .common-option-list-wrap .option-item");
+                await poperInstance.nth(1).waitFor();
+                await poperInstance.nth(1).click();
+                task.logger.info("地点选择完成");
+            }
+            if (params.collection) {
+                task.logger.info(`选择合集: ${params.collection.collectionName}`);
+                const instanceCollection = page.locator(".post-album-display-wrap");
+                await instanceCollection.click();
+                await page.waitForTimeout(1000);
+                page.locator(".post-album-wrap .option-item").filter({
+                    hasText: params.collection.collectionName
+                }).first().click({
+                    force: true
+                });
+            }
+            if (params.link) {
+                task.logger.info(`设置扩展阅读链接: ${params.link.title}`);
+                await page.locator(".post-link-wrap .link-display-wrap").click();
+                await page.waitForTimeout(300);
+                const linkTypeText = 2 === params.link.urlType ? "红包封面" : "公众号文章";
+                await page.locator(".link-option-item .title-wrap span").filter({
+                    hasText: linkTypeText
+                }).click();
+                await page.waitForTimeout(300);
+                const placeholder = 2 === params.link.urlType ? "粘贴红包封面链接" : "粘贴公众号文章链接";
+                await page.locator(`.link-input-wrap input[placeholder="${placeholder}"]`).fill(params.link.link);
+                await page.waitForTimeout(500);
+                task.logger.info(`已设置${linkTypeText}: ${params.link.link}`);
+            }
+            if (params.event) {
+                task.logger.info(`选择活动: ${params.event.eventName}`);
+                await page.locator(".post-activity-wrap .activity-display").click();
+                await page.waitForTimeout(500);
+                await page.locator(".activity-filter-wrap .weui-desktop-form__input[placeholder='搜索活动']").fill(params.event.eventName);
+                await page.waitForTimeout(500);
+                const searchLoading = page.locator(".search-loading");
+                await searchLoading.waitFor({
+                    state: "hidden",
+                    timeout: 5000
+                }).catch(()=>{
+                    task.logger.warn("活动搜索加载超时，继续尝试选择");
+                });
+                const activityItem = page.locator(".option-item .activity-item .activity-item-info .name").filter({
+                    hasText: params.event.eventName
+                });
+                const count = await activityItem.count();
+                if (count > 0) {
+                    await activityItem.first().click();
+                    await page.waitForTimeout(300);
+                    task.logger.info(`已选择活动: ${params.event.eventName}`);
+                } else {
+                    task.logger.warn(`未找到活动: ${params.event.eventName}，将不参与活动`);
+                    await page.locator(".post-activity-wrap .activity-display").click();
+                    await page.waitForTimeout(300);
+                }
+            }
+            if (params.scheduledTime) {
+                task.logger.info("设置定时发布");
+                const timingRadio = page.locator(".weui-desktop-form__check-label").filter({
+                    hasNotText: "不定时"
+                }).first();
+                await timingRadio.click();
+                await page.waitForTimeout(500);
+                const instance = page.locator(".weui-desktop-picker__date");
+                await instance.click();
+                const dateD = utils_TimeFormatter.format(1000 * params.scheduledTime, "d");
+                const nowMonth = utils_TimeFormatter.format(Date.now(), "MM月");
+                const nowMonthText = utils_TimeFormatter.format(Date.now(), "M月");
+                const month = utils_TimeFormatter.format(1000 * params.scheduledTime, "MM月");
+                const monthLocator = await page.locator("weui-desktop-picker__panel__label").filter({
+                    hasText: month
+                }).first();
+                if (!monthLocator) {
+                    await page.locator(".weui-desktop-picker__panel__label").filter({
+                        hasText: nowMonth
+                    }).first().click();
+                    await page.waitForTimeout(500);
+                    await page.locator(".weui-desktop-picker__table-row td a").filter({
+                        hasText: nowMonthText
+                    }).first().click();
+                }
+                await page.waitForTimeout(500);
+                await page.locator(".weui-desktop-picker__table-row td a").filter({
+                    hasText: dateD
+                }).first().click();
+                await page.locator(".weui-desktop-form__input-wrp input[placeholder*='请选择时间']").fill(utils_TimeFormatter.format(1000 * params.scheduledTime, "hh:mm"));
+                await page.locator("i.weui-desktop-icon__time").click();
+                await page.locator(".post-time-wrap .form-item .label").filter({
+                    hasText: "发表时间"
+                }).click();
+            }
+            if (params.tagInfo) {
+                task.logger.info(`设置视频标注: tagType=${params.tagInfo.tagType}`);
+                await page.locator(".mark-tag-select").click();
+                await page.waitForTimeout(300);
+                const tagTypeTextMap = {
+                    0: "无需标注",
+                    1: "含AI生成内容",
+                    2: "内容包含营销广告",
+                    3: "内容为虚构剧情，仅供娱乐",
+                    5: "内容为自行拍摄",
+                    7: "内容为转载",
+                    8: "个人观点，仅供参考"
+                };
+                const tagText = tagTypeTextMap[params.tagInfo.tagType];
+                if (tagText) {
+                    await page.locator(".mark-tag-option .option-main").filter({
+                        hasText: tagText
+                    }).click();
+                    await page.waitForTimeout(300);
+                    if (5 === params.tagInfo.tagType) {
+                        const shootInfo = params.tagInfo.shootInfo;
+                        if (shootInfo) {
+                            task.logger.info("填写拍摄时间和地点...");
+                            await page.waitForTimeout(500);
+                            if (shootInfo.postTimestamp) {
+                                task.logger.info(`设置拍摄时间: ${shootInfo.postTimestamp}`);
+                                const timestamp = 1000 * parseInt(shootInfo.postTimestamp, 10);
+                                const date = new Date(timestamp);
+                                await page.locator(".original-dialog-content .weui-desktop-picker__date input[placeholder*='请选择拍摄时间']").click();
+                                await page.waitForTimeout(300);
+                                const dayNum = date.getDate();
+                                await page.locator(".weui-desktop-picker__table a").filter({
+                                    hasText: new RegExp(`^\\s*${dayNum}\\s*$`)
+                                }).first().click();
+                                await page.waitForTimeout(300);
+                            }
+                            if (shootInfo.countryCode || shootInfo.provinceCode || shootInfo.cityCode) {
+                                task.logger.info("设置拍摄地点...");
+                                await page.locator(".original-dialog-content .weui-desktop-form__dropdowncascade .weui-desktop-form__dropdowncascade__dt").click();
+                                await page.waitForTimeout(300);
+                                if (1156 === shootInfo.countryCode) {
+                                    await page.locator(".weui-desktop-dropdown__list-ele .weui-desktop-dropdown__list-ele__text").filter({
+                                        hasText: "中国"
+                                    }).click();
+                                    await page.waitForTimeout(300);
+                                    task.logger.warn("RPA 模式下暂不支持选择具体省份和城市，仅选择了国家");
+                                } else task.logger.warn(`不支持的国家代码: ${shootInfo.countryCode}，跳过地点设置`);
+                            }
+                            const confirmBtn = await waitForElement(".weui-desktop-dialog .weui-desktop-btn_primary");
+                            if (confirmBtn) {
+                                await confirmBtn.click();
+                                await page.waitForTimeout(300);
+                            }
+                        } else task.logger.warn("tagType=5 需要提供 shootInfo 字段（拍摄时间和地点）");
+                    }
+                    if (7 === params.tagInfo.tagType) {
+                        const repostSource = params.tagInfo.repostSource;
+                        if (repostSource) {
+                            task.logger.info(`填写转载来源: ${repostSource}`);
+                            await page.waitForTimeout(500);
+                            await page.locator(".repost-dialog-content .repost-textarea").fill(repostSource);
+                            await page.waitForTimeout(300);
+                            const confirmBtn = await waitForElement(".weui-desktop-dialog .weui-desktop-btn_primary");
+                            if (confirmBtn) {
+                                await confirmBtn.click();
+                                await page.waitForTimeout(300);
+                            }
+                        } else task.logger.warn("tagType=7 需要提供 repostSource 字段（转载来源）");
+                    }
+                } else task.logger.warn(`未知的 tagType: ${params.tagInfo.tagType}，跳过标注设置`);
+            }
+            task.logger.info("准备发布...");
+            await page.waitForTimeout(500);
+            let videoId = "";
+            const handleResponse = async (response)=>{
+                const url = response.url();
+                if (url.includes("/post/post_create")) {
+                    const jsonResponse = await response.json();
+                    page.off("response", handleResponse);
+                    videoId = jsonResponse.object?.id || jsonResponse.data?.objectId || "";
+                }
+            };
+            page.on("response", handleResponse);
+            task._timerRecord.PrePublish = Date.now();
+            const MEDIA_OPR_SELECTOR = "#container-wrap > div.container-center > div > div > div.main-body-wrap.post-create > div.main-body > div > div.post-edit-wrap.material-edit-wrap > div.material > div.preview > div > div.media-opr > div > span > div > div > div";
+            task.logger.info("等待视频上传完成（预览区媒体操作栏出现）...");
+            const uploadTimeout = 600000;
+            const uploadWaitStart = Date.now();
+            let lastProgressLog = 0;
+            while(true){
+                const ready = await page.evaluate((selector)=>{
+                    const host = document.querySelector("#container-wrap > div.container-center > div > wujie-app");
+                    const root = host?.shadowRoot;
+                    if (!root) return false;
+                    return !!root.querySelector(selector);
+                }, MEDIA_OPR_SELECTOR);
+                if (ready) break;
+                const elapsed = Date.now() - uploadWaitStart;
+                if (elapsed > uploadTimeout) throw new Error(`视频上传超时，预览区未就绪（已等待 ${Math.round(elapsed / 1000)}s）`);
+                if (elapsed - lastProgressLog >= 15000) {
+                    lastProgressLog = elapsed;
+                    task.logger.info(`视频仍在上传中... 已等待 ${Math.round(elapsed / 1000)}s`);
+                }
+                await page.waitForTimeout(1000);
+            }
+            task.logger.info(`视频上传完成（等待 ${Math.round((Date.now() - uploadWaitStart) / 1000)}s）`);
+            const clicked = await page.evaluate(()=>{
+                const host = document.querySelector("#container-wrap > div.container-center > div > wujie-app");
+                const root = host?.shadowRoot;
+                if (!root) return "未找到 wujie-app shadowRoot";
+                const btns = Array.from(root.querySelectorAll(".form-btns .weui-desktop-btn"));
+                const target = btns.find((el)=>(el.textContent || "").includes("发表"));
+                if (!target) return "未找到发表按钮";
+                if (target.classList.contains("weui-desktop-btn_disabled")) return "发表按钮仍处于禁用状态";
+                target.click();
+                return null;
+            });
+            if (clicked) throw new Error(clicked);
+            task.logger.info("已点击发布按钮，等待响应...");
+            try {
+                await page.waitForURL((url)=>url.href !== page.url(), {
+                    timeout: 30000
+                });
+                task.logger.info(`发布成功，页面已跳转: ${page.url()}`);
+            } catch  {
+                task.logger.warn("等待页面跳转超时，可能发布失败或网络慢，继续关闭页面");
+            }
+            await page.close();
+            return (0, share_namespaceObject.success)(videoId, "发布成功");
+        } catch (error) {
+            let errorMsg = error instanceof Error ? error.message : String(error);
+            if (errorMsg.includes("context or browser has been closed")) errorMsg = "浏览器上下文已被关闭";
+            task.logger.error(`微信视频号视频发布失败: ${errorMsg}`);
+            return (0, share_namespaceObject.response)(414, `微信视频号视频发布失败: ${errorMsg}`, "");
+        }
+    };
+    const ShipinhaoPublishVideoParamsSchema = ActionCommonParamsSchema.extend({
+        videoPath: schemas_string().min(1),
+        videoMetadata: schemas_object({
+            duration: schemas_number().positive(),
+            width: schemas_number().int().positive(),
+            height: schemas_number().int().positive(),
+            fileSize: schemas_number().int().positive(),
+            path: schemas_string().min(1).optional(),
+            fileName: schemas_string().min(1)
+        }),
+        coverPath: schemas_string().min(1),
+        verticalCoverPath: schemas_string().min(1).optional(),
+        description: schemas_string(),
+        title: schemas_string().optional(),
+        scheduledTime: schemas_number().int().positive().optional(),
+        isImmediatelyPublish: schemas_boolean().optional(),
+        topics: schemas_array(schemas_string()).optional(),
+        mentionedUsers: schemas_array(schemas_object({
+            nickname: schemas_string()
+        })).optional(),
+        collection: schemas_object({
+            collectionId: schemas_string(),
+            collectionName: schemas_string()
+        }).optional(),
+        event: schemas_object({
+            eventTopicId: schemas_string(),
+            eventName: schemas_string(),
+            eventCreatorNickname: schemas_string().optional()
+        }).optional(),
+        link: schemas_object({
+            link: schemas_string(),
+            title: schemas_string(),
+            urlType: schemas_number().int().default(1)
+        }).optional(),
+        tagInfo: looseObject({
+            tagType: schemas_number().int()
+        }).optional(),
+        originalFlag: union([
+            literal(0),
+            literal(1)
+        ]).optional(),
+        postWithMemberZoneLink: union([
+            literal(0),
+            literal(1)
+        ]).optional(),
+        location: schemas_object({
+            latitude: schemas_number(),
+            longitude: schemas_number(),
+            city: schemas_string(),
+            poiName: schemas_string().optional(),
+            address: schemas_string().optional(),
+            poiClassifyId: schemas_string().optional()
+        }).optional()
+    });
+    const shipinhaoPublishVideo = async (task, params)=>{
+        task.logger.info(`[shipinhaoPublishVideo] actionType: ${params.actionType}`);
+        if ("rpa" === params.actionType) return shipinhaoPublishVideo_rpa_rpaAction(task, params);
+        if ("mockApi" === params.actionType) return shipinhaoPublishVideo_mock_mockAction(task, params);
+        return executeAction(shipinhaoPublishVideo_mock_mockAction, shipinhaoPublishVideo_rpa_rpaAction)(task, params);
+    };
+    const ShipinhaoSendMsgParamsSchema = ActionCommonParamsSchema.extend({
+        toUsername: schemas_string().min(1, "接收者用户名不能为空"),
+        sessionId: schemas_string().min(1, "会话ID不能为空"),
+        msgType: schemas_enum([
+            "TEXT",
+            "IMAGE"
+        ], {
+            message: "消息类型必须是 TEXT 或 IMAGE"
+        }),
+        content: schemas_string().optional(),
+        imageInfo: schemas_object({
+            pathOrUrl: schemas_string().min(1, "图片路径或URL不能为空")
+        }).optional()
+    });
+    const shipinhaoSendMsg_CHUNK_SIZE = 524288;
+    async function shipinhaoSendMsg_getUserInfo(cookieStr, http) {
+        const url = `https://channels.weixin.qq.com/cgi-bin/mmfinderassistant-bin/auth/auth_data?_rid=${rid()}`;
+        const headers = {
+            referer: "https://channels.weixin.qq.com/micro/interaction/private_msg",
+            cookie: cookieStr,
+            Origin: "https://channels.weixin.qq.com"
+        };
+        return await http.api({
+            method: "get",
+            url,
+            headers
+        }, {
+            retries: 3,
+            retryDelay: 1000,
+            timeout: 10000
+        });
+    }
+    const shipinhaoSendMsg = async (_task, params)=>{
+        if (!params.sessionId) return (0, share_namespaceObject.response)(414, "sessionId 不能为空", void 0);
+        if (!params.toUsername) return (0, share_namespaceObject.response)(414, "接收者用户名不能为空", void 0);
+        if (!params.msgType) return (0, share_namespaceObject.response)(414, "消息类型不能为空", void 0);
+        if (![
+            "TEXT",
+            "IMAGE"
+        ].includes(params.msgType)) return (0, share_namespaceObject.response)(414, "消息类型必须是 TEXT 或 IMAGE", void 0);
+        if ("TEXT" === params.msgType) {
+            if (!params.content || "" === params.content.trim()) return (0, share_namespaceObject.response)(414, "消息内容不能为空", void 0);
+        }
+        if ("IMAGE" === params.msgType) {
+            if (!params.imageInfo?.pathOrUrl) return (0, share_namespaceObject.response)(414, "图片路径或URL不能为空", void 0);
+        }
+        if (!params.extraParam) return (0, share_namespaceObject.response)(414, "缺少 extraParam 参数", void 0);
+        if (!params.extraParam.fingerPrintDeviceId || !params.extraParam.aId || !params.extraParam.uin) return (0, share_namespaceObject.response)(414, "fingerPrintDeviceId、aId 和 uin 不能为空", void 0);
+        const cookieStr = params.cookies.map((it)=>`${it.name}=${it.value}`).join(";");
+        const headers = {
+            cookie: cookieStr,
+            referer: "https://channels.weixin.qq.com/micro/interaction/private_msg",
+            origin: "https://channels.weixin.qq.com",
+            "content-type": "application/json",
+            "finger-print-device-id": params.extraParam.fingerPrintDeviceId,
+            "x-wechat-uin": params.extraParam.uin
+        };
+        const http = new Http({
+            headers
+        });
+        const urlParams = new URLSearchParams({
+            _aid: params.extraParam.aId,
+            _rid: rid(),
+            _pageUrl: "https://channels.weixin.qq.com/micro/interaction/private_msg"
+        }).toString();
+        const generateCliMsgId = ()=>"xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (s)=>{
+                const t = 16 * Math.random() | 0;
+                return ("x" === s ? t : 3 & t | 8).toString(16);
+            });
+        let fromUsername = params.extraParam.finderUserName;
+        if (!fromUsername) {
+            _task.logger.info("未提供 finderUserName，尝试获取用户信息");
+            const userInfoRes = await shipinhaoSendMsg_getUserInfo(cookieStr, http);
+            if (!userInfoRes.data?.finderUser?.finderUsername) return (0, share_namespaceObject.response)(userInfoRes.errCode || -1, userInfoRes.errMsg || "获取用户信息失败", {});
+            fromUsername = userInfoRes.data.finderUser.finderUsername;
+            _task.logger.info(`获取到用户名: ${fromUsername}`);
+        }
+        let imgMsg;
+        if ("IMAGE" === params.msgType) {
+            let imageBuffer;
+            const imagePath = params.imageInfo.pathOrUrl;
+            try {
+                if (imagePath.startsWith("http://") || imagePath.startsWith("https://")) {
+                    const resp = await external_axios_default().get(imagePath, {
+                        responseType: "arraybuffer"
+                    });
+                    imageBuffer = Buffer.from(resp.data);
+                } else {
+                    const filePath = imagePath.startsWith("file://") ? imagePath.slice(7) : imagePath;
+                    imageBuffer = Buffer.from(await external_node_fs_default().promises.readFile(filePath));
+                }
+            } catch (err) {
+                _task.logger.error(`读取图片失败: ${err instanceof Error ? err.message : String(err)}`);
+                return (0, share_namespaceObject.response)(414, USER_MESSAGE.IMAGE_UPLOAD_FAILED, void 0);
+            }
+            const md5 = (0, external_node_crypto_namespaceObject.createHash)("md5").update(imageBuffer).digest("hex");
             const timestamp = Date.now().toString();
-            const totalChunks = Math.ceil(imageBuffer.length / CHUNK_SIZE);
+            const totalChunks = Math.ceil(imageBuffer.length / shipinhaoSendMsg_CHUNK_SIZE);
             console.log(`分片上传md5${md5}`);
             let lastRes;
             for(let i = 0; i < totalChunks; i++){
-                const chunkBuffer = imageBuffer.slice(i * CHUNK_SIZE, (i + 1) * CHUNK_SIZE);
+                const chunkBuffer = imageBuffer.slice(i * shipinhaoSendMsg_CHUNK_SIZE, (i + 1) * shipinhaoSendMsg_CHUNK_SIZE);
                 const requestData = {
                     content: `data:application/octet-stream;base64,${chunkBuffer.toString("base64")}`,
                     chunk: i,
@@ -20069,6 +21932,13 @@ var __webpack_exports__ = {};
         const uploadImages = async (images)=>await Promise.all(images.map(async (url)=>{
                 const fileName = (0, share_namespaceObject.getFilenameFromUrl)(url);
                 const image = await (0, share_namespaceObject.downloadImage)(url, external_node_path_default().join(tmpCachePath, fileName));
+                const stats = external_node_fs_default().statSync(image);
+                const maxSize = 20971520;
+                if (stats.size > maxSize) throw {
+                    code: 414,
+                    message: "头条号平台：单张图片不得超过 20MB",
+                    data: ""
+                };
                 const formData = new (external_form_data_default())();
                 formData.append("image", external_node_fs_default().createReadStream(image));
                 const response = await http.api({
@@ -22119,18 +23989,10 @@ var __webpack_exports__ = {};
             });
         } catch (error) {
             const handledError = Http.handleApiError(error);
-            const isProxyOrNetworkError = [
-                599,
-                500,
-                502,
-                503,
-                504
-            ].includes(handledError.code);
-            if (isProxyOrNetworkError) {
-                const isProxyRequest = handledError.extra?.isProxyRequest === true;
-                const errorType = 599 === handledError.code || isProxyRequest ? "代理错误" : "网络错误";
-                const message = `文章发布失败，${errorType}：${handledError.message}${task.debug ? ` ${http.proxyInfo}` : ""}`;
-                task.logger.error(`[weixinPublish] ${errorType}，直接返回: ${message}`, stringifyError(handledError));
+            const classified = classifyPublishError(handledError);
+            if (classified) {
+                const message = `${classified.userMessage}${task.debug ? ` ${http.proxyInfo}` : ""}`;
+                task.logger.error(`[weixinPublish] ${classified.category}，直接返回: ${handledError.message} (code=${handledError.code})`, stringifyError(handledError));
                 await updateTaskState?.({
                     state: share_namespaceObject.TaskState.FAILED,
                     error: message
@@ -23360,6 +25222,12 @@ var __webpack_exports__ = {};
             const fileName = (0, share_namespaceObject.getFilenameFromUrl)(url);
             const localUrl = await (0, share_namespaceObject.downloadImage)(url, external_node_path_default().join(tmpCachePath, fileName));
             const fileBuffer = external_node_fs_default().readFileSync(localUrl);
+            const maxSize = 33554432;
+            if (fileBuffer.byteLength > maxSize) throw {
+                code: 414,
+                message: "小红书平台：单张图片不得超过 32MB",
+                data: ""
+            };
             let width = 0;
             let height = 0;
             try {
@@ -23598,6 +25466,7 @@ var __webpack_exports__ = {};
             });
             return (0, share_namespaceObject.success)(data, message);
         }
+        task.logger.info(`[xiaohongshuPublish] publishData: ${JSON.stringify(publishData)} `);
         let publishResult;
         try {
             publishResult = await proxyHttp.api({
@@ -23608,23 +25477,15 @@ var __webpack_exports__ = {};
                 defaultErrorMsg: "文章发布异常，请稍后重试。"
             }, {
                 retries: 2,
-                retryDelay: 500,
-                timeout: 12000
+                retryDelay: 3000,
+                timeout: 30000
             });
         } catch (error) {
             const handledError = Http.handleApiError(error);
-            const isProxyOrNetworkError = [
-                599,
-                500,
-                502,
-                503,
-                504
-            ].includes(handledError.code);
-            if (isProxyOrNetworkError) {
-                const isProxyRequest = handledError.extra?.isProxyRequest === true;
-                const errorType = 599 === handledError.code || isProxyRequest ? "代理错误" : "网络错误";
-                const message = `文章发布失败，${errorType}：${handledError.message}${task.debug ? ` ${http.proxyInfo}` : ""}`;
-                task.logger.error(`[xiaohongshuPublish] ${errorType}，直接返回: ${message}`, stringifyError(handledError));
+            const classified = classifyPublishError(handledError);
+            if (classified) {
+                const message = `${classified.userMessage}${task.debug ? ` ${http.proxyInfo}` : ""}`;
+                task.logger.error(`[xiaohongshuPublish] ${classified.category}，直接返回: ${handledError.message} (code=${handledError.code})`, stringifyError(handledError));
                 await updateTaskState?.({
                     state: share_namespaceObject.TaskState.FAILED,
                     error: message
@@ -25320,6 +27181,14 @@ var __webpack_exports__ = {};
             this.task = task;
             this.task.logger.info(`当前包版本：Share=>${package_json_default().version} Action=>${package_namespaceObject.i8}`);
         }
+        getActionVersionMarker() {
+            return {
+                version: package_namespaceObject.i8,
+                shareVersion: package_json_default().version,
+                marker: `Action_${package_namespaceObject.i8}_${package_json_default().version}`,
+                timestamp: new Date().toLocaleString()
+            };
+        }
         async bindTask(func, params) {
             let responseData;
             this.task.isBeta = this.task?.isFeatOn ? this.task?.isFeatOn(BetaFlag) : false;
@@ -25543,6 +27412,9 @@ var __webpack_exports__ = {};
         shipinhaoPublish(params) {
             return this.bindTask(shipinhaoPublish, params);
         }
+        shipinhaoPublishVideo(params) {
+            return this.bindTask(shipinhaoPublishVideo, params);
+        }
         douyinGetTopics(params) {
             return this.bindTask(douyinGetTopics, params);
         }
@@ -25603,4 +27475,4 @@ if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_targe
 });
 
 //# sourceMappingURL=index.js.map
-//# debugId=4505f4f9-b586-5fae-8a9f-3ce0ceb72967
+//# debugId=4653233b-4a56-52c6-8a3b-2a28934c66cb