@iflyrpa/actions 4.0.9-beta.3 → 4.1.0-beta.5

package/dist/index.js

@@ -1,3 +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]="1de33b63-4038-5f51-813c-0899b138a5ca")}catch(e){}}();
 var __webpack_modules__ = {
     "./src/utils/XhsXsCommonEnc.js": function(module) {
         var encrypt_lookup = [
@@ -4364,6 +4366,7 @@ var __webpack_exports__ = {};
         SessionCheckResultSchema: ()=>SessionCheckResultSchema,
         DouyinGetCommentReplyListParamsSchema: ()=>DouyinGetCommentReplyListParamsSchema,
         DouyinCreateCommentReplyParamsSchema: ()=>DouyinCreateCommentReplyParamsSchema,
+        ShipinhaoPublishVideoParamsSchema: ()=>ShipinhaoPublishVideoParamsSchema,
         DouyinGetHotParamsSchema: ()=>DouyinGetHotParamsSchema,
         DouyinGetMusicParamsSchema: ()=>DouyinGetMusicParamsSchema,
         FetchArticlesDataSchema: ()=>FetchArticlesDataSchema,
@@ -4400,7 +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 = JSON.parse('{"i8":"4.0.9-beta.3"}');
+    var package_namespaceObject = JSON.parse('{"i8":"4.1.0-beta.5"}');
     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);
@@ -4869,22 +4872,32 @@ var __webpack_exports__ = {};
             const retries = options?.retries ?? 0;
             const retryDelay = options?.retryDelay ?? 500;
             const reqTimeout = options?.timeout ?? 30000;
+            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) {
@@ -6001,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)$/;
@@ -6687,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)=>{
@@ -9323,6 +9336,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");
@@ -13460,6 +13480,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 {
@@ -19706,6 +19731,1086 @@ 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);
     };
+    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: "获取用户信息失败"
+        });
+    }
+    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";
+        }
+    }
+    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 CHUNK_SIZE = 8388608;
+    async function uploader_uploadFile(opts) {
+        const { filePath, fileType, uin, authKey, http, logger } = opts;
+        const stat = external_node_fs_default().statSync(filePath);
+        const fileSize = stat.size;
+        const fileName = filePath.split(/[\\/]/).pop() || "file";
+        logger?.info(`开始上传: ${fileName} (${fileSize} B, filetype=${fileType})`);
+        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
+            }
+        });
+        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
+                }
+            });
+            uploadId = retryRes.UploadID;
+            if (!uploadId) throw new Error("续传获取 UploadID 失败");
+        }
+        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;
+                    }
+                }
+                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");
+                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
+                });
+                partInfo.push({
+                    PartNumber: partNumber,
+                    ETag: `"${chunkMd5}"`
+                });
+                logger?.info(`分片 ${partNumber}/${chunkCount} 完成 (${chunkSize} B)`);
+            }
+        } 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
+            }
+        });
+        if (!completeRes.DownloadURL) throw new Error("合并分片失败: " + JSON.stringify(completeRes));
+        logger?.info(`上传成功: ${completeRes.DownloadURL.slice(0, 80)}...`);
+        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);
+    }
+    function parseVideoMeta(filePath) {
+        let buf;
+        try {
+            buf = external_node_fs_default().readFileSync(filePath);
+        } catch  {
+            return null;
+        }
+        let movie = null;
+        const tracks = [];
+        function walk(start, end) {
+            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 "moov":
+                    case "trak":
+                    case "mdia":
+                    case "minf":
+                    case "stbl":
+                        walk(bodyStart, bodyEnd);
+                        break;
+                    case "mvhd":
+                        movie = parseMvhd(buf, bodyStart, bodyEnd);
+                        break;
+                    case "tkhd":
+                        tracks.push({
+                            ...parseTkhd(buf, bodyStart, bodyEnd),
+                            handler: null,
+                            codec: null
+                        });
+                        break;
+                    case "hdlr":
+                        if (bodyEnd - bodyStart >= 12) {
+                            const handler = buf.toString("latin1", bodyStart + 8, bodyStart + 12);
+                            if (tracks.length) tracks[tracks.length - 1].handler = handler;
+                        }
+                        break;
+                    case "stsd":
+                        {
+                            const codec = parseStsdCodec(buf, bodyStart, bodyEnd);
+                            if (codec && tracks.length) tracks[tracks.length - 1].codec = codec;
+                            break;
+                        }
+                }
+                off += size;
+            }
+        }
+        walk(0, buf.length);
+        const video = tracks.find((t)=>"vide" === t.handler) || tracks.find((t)=>t.width > 0 && t.height > 0);
+        if (!movie || !video) return null;
+        const movieData = movie;
+        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: movieData.timescale ? movieData.duration / movieData.timescale : 0,
+            rotation: video.rotation,
+            fileSize: buf.length,
+            codec: video.codec
+        };
+    }
+    function parseStsdCodec(buf, start, end) {
+        if (start + 16 > end) 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;
+        if (whOff + 8 > end) return {
+            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 {
+            width,
+            height,
+            rotation
+        };
+    }
+    const MAX_DURATION_SECONDS = 28800;
+    const MAX_FILE_SIZE = 21474836480;
+    const ALLOWED_EXTENSIONS = [
+        ".mp4"
+    ];
+    const ALLOWED_CODECS = [
+        "avc1",
+        "avc3"
+    ];
+    const MIN_TITLE_LENGTH = 6;
+    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();
+        const length = [
+            ...trimmed
+        ].length;
+        if (length < MIN_TITLE_LENGTH) return `视频号标题至少需要 ${MIN_TITLE_LENGTH} 个字符，请补充后重试。`;
+        return null;
+    }
+    async function getTraceKey(auth, http, logger) {
+        logger.info("[getTraceKey] 开始获取 traceKey...");
+        const res = await http.api({
+            method: "POST",
+            url: "https://channels.weixin.qq.com/micro/content/cgi-bin/mmfinderassistant-bin/post/get-finder-post-trace-key",
+            data: {
+                objectId: "",
+                timestamp: String(Date.now()),
+                _log_finder_uin: "",
+                _log_finder_id: auth.finderUsername,
+                rawKeyBuff: "",
+                pluginSessionId: null,
+                scene: 7,
+                reqScene: 7
+            },
+            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 submitAndPollTranscode(opts) {
+        const { videoUrl, videoMeta, traceKey, uploadStartTime, uploadEndTime, finderUsername, 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] 视频URL: ${finderUrl}`);
+        logger.info(`[submitAndPollTranscode] 视频尺寸: ${videoMeta.width}x${videoMeta.height}, 时长: ${videoMeta.duration}s`);
+        const submitRes = await http.api({
+            method: "POST",
+            url: "https://channels.weixin.qq.com/micro/content/cgi-bin/mmfinderassistant-bin/post/post_clip_video",
+            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,
+                timestamp: String(Date.now()),
+                _log_finder_uin: "",
+                _log_finder_id: finderUsername,
+                rawKeyBuff: "",
+                pluginSessionId: null,
+                scene: 7,
+                reqScene: 7
+            },
+            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 maxPolls = 60;
+        const pollInterval = 5000;
+        let pollCount = 0;
+        logger.info(`[submitAndPollTranscode] 开始轮询转码结果，最多 ${maxPolls} 次，间隔 ${pollInterval / 1000}s`);
+        while(pollCount < maxPolls){
+            await sleep(pollInterval);
+            pollCount++;
+            const pollRes = await http.api({
+                method: "POST",
+                url: "https://channels.weixin.qq.com/micro/content/cgi-bin/mmfinderassistant-bin/post/post_clip_video_result",
+                data: {
+                    clipKey,
+                    draftId,
+                    timestamp: String(Date.now()),
+                    _log_finder_uin: "",
+                    _log_finder_id: finderUsername,
+                    rawKeyBuff: "",
+                    pluginSessionId: null,
+                    scene: 7,
+                    reqScene: 7
+                },
+                defaultErrorMsg: "转码轮询失败"
+            });
+            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, clipResult, videoUpload, coverUpload, traceKey, uploadStartTime, uploadEndTime, proxyHttp, logger } = opts;
+        logger.info("[publishVideo] 开始构建发布请求...");
+        const coverFinderUrl = coverUpload.downloadUrl.includes("wxapp.tc.qq.com") ? `https://finder.video.qq.com${coverUpload.downloadUrl.split("qq.com")[1]}` : coverUpload.downloadUrl;
+        logger.info(`[publishVideo] 封面URL: ${coverFinderUrl}`);
+        const md5sumUuid = external_node_crypto_default().randomUUID();
+        logger.info("[publishVideo] 发布参数:");
+        logger.info(`  - 标题: ${params.title || "(无)"}`);
+        logger.info(`  - 描述: ${params.description?.substring(0, 50)}${params.description?.length > 50 ? "..." : ""}`);
+        logger.info(`  - 定时发布: ${params.scheduleTime ? new Date(1000 * params.scheduleTime).toLocaleString() : "立即发布"}`);
+        logger.info(`  - 地理位置: ${params.location ? `${params.location.city} (${params.location.latitude},${params.location.longitude})` : "(无)"}`);
+        const publishRes = await proxyHttp.api({
+            method: "POST",
+            url: "https://channels.weixin.qq.com/micro/content/cgi-bin/mmfinderassistant-bin/post/post_create",
+            data: {
+                objectType: 0,
+                longitude: params.location?.longitude || 0,
+                latitude: params.location?.latitude || 0,
+                feedLongitude: 0,
+                feedLatitude: 0,
+                originalFlag: 0,
+                topics: [],
+                isFullPost: 1,
+                handleFlag: 2,
+                videoClipTaskId: clipResult.clipKey,
+                traceInfo: {
+                    traceKey,
+                    uploadCdnStart: uploadStartTime,
+                    uploadCdnEnd: uploadEndTime
+                },
+                objectDesc: {
+                    mpTitle: "",
+                    description: params.description,
+                    shortTitle: params.title || "",
+                    extReading: {},
+                    mediaType: 4,
+                    location: params.location ? {
+                        latitude: params.location.latitude,
+                        longitude: params.location.longitude,
+                        city: params.location.city,
+                        poiClassifyId: params.location.poiClassifyId || ""
+                    } : {
+                        latitude: 0,
+                        longitude: 0,
+                        city: "",
+                        poiClassifyId: ""
+                    },
+                    topic: {
+                        finderTopicInfo: `<finder><version>1</version><valuecount>1</valuecount><style><at></at></style><value0><![CDATA[${params.description}]]></value0></finder>`
+                    },
+                    event: {},
+                    mentionedUser: [],
+                    media: [
+                        {
+                            url: clipResult.url,
+                            fileSize: clipResult.fileSize,
+                            thumbUrl: coverFinderUrl,
+                            fullThumbUrl: coverFinderUrl,
+                            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
+                        }
+                    ],
+                    member: {}
+                },
+                effectiveTime: params.scheduleTime || 0,
+                report: {
+                    clipKey: clipResult.clipKey,
+                    draftId: clipResult.clipKey,
+                    timestamp: String(Date.now()),
+                    _log_finder_uin: "",
+                    _log_finder_id: auth.finderUsername,
+                    rawKeyBuff: "",
+                    pluginSessionId: null,
+                    scene: 7,
+                    reqScene: 7,
+                    height: clipResult.height,
+                    width: clipResult.width,
+                    duration: clipResult.duration,
+                    fileSize: videoUpload.fileSize,
+                    uploadCost: (uploadEndTime - uploadStartTime) * 1000
+                },
+                postFlag: 0,
+                mode: 1,
+                clientid: external_node_crypto_default().randomUUID(),
+                timestamp: String(Date.now()),
+                _log_finder_uin: "",
+                _log_finder_id: auth.finderUsername,
+                rawKeyBuff: "",
+                pluginSessionId: null,
+                scene: 7,
+                reqScene: 7
+            },
+            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));
+    }
+    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 {
+            currentStep = "解析认证信息";
+            const cookieString = params.cookies.map((c)=>`${c.name}=${c.value}`).join("; ");
+            const headers = {
+                cookie: cookieString
+            };
+            const args = [
+                {
+                    headers
+                },
+                task.logger,
+                params.proxyLoc,
+                params.accountId,
+                "shipinhao"
+            ];
+            const http = new Http({
+                headers
+            });
+            const proxyHttp = new Http(...args);
+            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);
+            currentStep = "解析视频元数据";
+            task.logger.info("[shipinhaoPublishVideo] 解析视频元数据...");
+            const videoMeta = parseVideoMeta(params.videoPath);
+            if (!videoMeta) return (0, share_namespaceObject.response)(414, "视频文件解析失败，请检查文件格式（仅支持 MP4）", "");
+            task.logger.info(`[shipinhaoPublishVideo] 视频: ${videoMeta.width}×${videoMeta.height}, ${videoMeta.duration.toFixed(2)}s, ${(videoMeta.fileSize / 1024 / 1024).toFixed(2)}MB, codec=${videoMeta.codec || "unknown"}`);
+            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, http, 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] 视频上传完成，URL: ${videoUpload.downloadUrl}`);
+            const uploadEndTime = Math.floor(Date.now() / 1000);
+            task.logger.info(`[shipinhaoPublishVideo] 上传结束时间: ${uploadEndTime}, 耗时: ${uploadEndTime - uploadStartTime}s`);
+            currentStep = "上传封面";
+            task.logger.info("[shipinhaoPublishVideo] 上传封面...");
+            task.logger.info(`[shipinhaoPublishVideo] 封面路径: ${params.coverPath}`);
+            task.logger.info(`[shipinhaoPublishVideo] 封面文件类型: ${auth.pictureFileType}`);
+            const coverUpload = await uploader_uploadFile({
+                filePath: params.coverPath,
+                fileType: auth.pictureFileType,
+                uin: auth.uin,
+                authKey: auth.authKey,
+                http,
+                logger: task.logger
+            });
+            task.logger.info(`[shipinhaoPublishVideo] 封面上传完成，URL: ${coverUpload.downloadUrl}`);
+            currentStep = "提交转码";
+            task.logger.info("[shipinhaoPublishVideo] 提交转码...");
+            const clipResult = await submitAndPollTranscode({
+                videoUrl: videoUpload.downloadUrl,
+                videoMeta,
+                traceKey,
+                uploadStartTime,
+                uploadEndTime,
+                finderUsername: auth.finderUsername,
+                http,
+                logger: task.logger
+            });
+            currentStep = "发布视频";
+            task.logger.info("[shipinhaoPublishVideo] 发布视频...");
+            task.logger.info(`[shipinhaoPublishVideo] clipKey: ${clipResult.clipKey}`);
+            let publishResult;
+            try {
+                publishResult = await publishVideo({
+                    params,
+                    auth,
+                    clipResult,
+                    videoUpload,
+                    coverUpload,
+                    traceKey,
+                    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 ?? "发布成功";
+            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}`);
+                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
+                    },
+                    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 = "未登录";
+            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 = parseVideoMeta(params.videoPath);
+        if (!videoMeta) return (0, share_namespaceObject.response)(414, "视频文件解析失败，请检查文件格式（仅支持 MP4）", "");
+        task.logger.info(`视频: ${videoMeta.width}×${videoMeta.height}, ${videoMeta.duration.toFixed(2)}s, ${(videoMeta.fileSize / 1024 / 1024).toFixed(2)}MB, codec=${videoMeta.codec || "unknown"}`);
+        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 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);
+                    }
+                });
+            }
+            if (params.description) {
+                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(params.description, {
+                        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.scheduleTime) {
+                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.scheduleTime, "d");
+                const nowMonth = utils_TimeFormatter.format(Date.now(), "MM月");
+                const nowMonthText = utils_TimeFormatter.format(Date.now(), "M月");
+                const month = utils_TimeFormatter.format(1000 * params.scheduleTime, "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.scheduleTime, "hh:mm"));
+                await page.locator("i.weui-desktop-icon__time").click();
+                await page.locator(".post-time-wrap .form-item .label").filter({
+                    hasText: "发表时间"
+                }).click();
+            }
+            task.logger.info("准备发布...");
+            await page.waitForTimeout(300);
+            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),
+        coverPath: schemas_string().min(1),
+        description: schemas_string(),
+        title: schemas_string().optional(),
+        scheduleTime: schemas_number().int().positive().optional(),
+        location: schemas_object({
+            latitude: schemas_number(),
+            longitude: schemas_number(),
+            city: schemas_string(),
+            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不能为空"),
@@ -19720,7 +20825,7 @@ var __webpack_exports__ = {};
             pathOrUrl: schemas_string().min(1, "图片路径或URL不能为空")
         }).optional()
     });
-    const CHUNK_SIZE = 524288;
+    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 = {
@@ -19803,11 +20908,11 @@ var __webpack_exports__ = {};
             }
             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,
@@ -20260,6 +21365,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({
@@ -23543,6 +24655,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 {
@@ -25727,6 +26845,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);
         }
@@ -25786,4 +26907,5 @@ if (__webpack_exports__.__esModule) Object.defineProperty(__webpack_export_targe
     value: true
 });
 
-//# sourceMappingURL=index.js.map
+//# sourceMappingURL=index.js.map
+//# debugId=1de33b63-4038-5f51-813c-0899b138a5ca