octoparse-cli 0.1.14

package/node_modules/@octopus/engine/dist/actions/NavigateAction.d.ts

@@ -0,0 +1,38 @@
+import NavigateConfig from '../configs/NavigateConfig';
+import BaseAction from './BaseAction';
+export default class NavigateAction extends BaseAction {
+    config: NavigateConfig;
+    private page;
+    private url;
+    private retryTimes;
+    private retryIsNeed;
+    executeTimeMax: number;
+    get isAutoCloudflare(): boolean;
+    protected parseConfig(config: any): NavigateConfig;
+    /** 设置 Turnstile 拦截器 */
+    private setupTurnstileInterceptor;
+    private isTransientRiskControlStatus;
+    /**
+     * 某些站点会先返回 412/403 风控挑战页，再由页面脚本自动刷新为 200 正常页。
+     * 独立浏览器能看到最终页面，但如果只看首个 goto 响应会被误判成“打开网页失败”。
+     */
+    private resolveFinalNavigationResponse;
+    private getErrorMessage;
+    private execute;
+    /** 清理当前网站的缓存 */
+    private clearCache;
+    /** 设置已保存的 Cookies */
+    private setCookies;
+    /** 判定是否需要重试 */
+    private checkRetry;
+    private parseCookies;
+    start(): void;
+    wait(): Promise<void>;
+    onPageLoading(url: string): void;
+    onPageLoaded(url: string): Promise<void>;
+    retry(): Promise<true>;
+    fixCloudflare(): Promise<void>;
+    judgeHasTurnstile(): Promise<unknown>;
+    onJsonResponse(): Promise<void>;
+    onJsonError(): void;
+}

package/node_modules/@octopus/engine/dist/actions/NavigateAction.js

@@ -0,0 +1,535 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const NavigateConfig_1 = __importDefault(require("../configs/NavigateConfig"));
+const enums_1 = require("../enums");
+const conditionCheckArgs_1 = require("../models/conditionCheckArgs");
+const utils_1 = require("../utils");
+const BaseAction_1 = __importDefault(require("./BaseAction"));
+class NavigateAction extends BaseAction_1.default {
+    constructor() {
+        super(...arguments);
+        this.url = '';
+        this.retryTimes = 0;
+        this.retryIsNeed = false;
+        this.executeTimeMax = -1;
+    }
+    get isAutoCloudflare() {
+        var _a, _b;
+        return (_b = (_a = this.browserProxy.brokerSettings) === null || _a === void 0 ? void 0 : _a.captchaSettings) === null || _b === void 0 ? void 0 : _b.isAutoCloudflare;
+    }
+    parseConfig(config) {
+        return new NavigateConfig_1.default(config, this.activity.activity.extensionElements);
+    }
+    /** 设置 Turnstile 拦截器 */
+    async setupTurnstileInterceptor() {
+        await this.page.evaluateOnNewDocument(`
+    let i = setInterval(() => {
+          if (window.turnstile) {
+              clearInterval(i)
+              window.turnstile.render = (a, b) => {
+                  let params = {
+                      sitekey: b.sitekey,
+                      pageurl: window.location.href,
+                      data: b.cData,
+                      pagedata: b.chlPageData,
+                      action: b.action,
+                      userAgent: navigator.userAgent,
+                      json: 1
+                  }
+                  window.turnstileFreezeParams = params;
+                  window.turnstileCallback = b.callback;
+                  return
+              }
+          }
+      }, 1)
+    `);
+    }
+    isTransientRiskControlStatus(statusCode) {
+        return statusCode === 403 || statusCode === 412 || statusCode === 429;
+    }
+    /**
+     * 某些站点会先返回 412/403 风控挑战页，再由页面脚本自动刷新为 200 正常页。
+     * 独立浏览器能看到最终页面，但如果只看首个 goto 响应会被误判成“打开网页失败”。
+     */
+    async resolveFinalNavigationResponse(response) {
+        var _a;
+        const statusCode = (_a = response === null || response === void 0 ? void 0 : response.status) === null || _a === void 0 ? void 0 : _a.call(response);
+        if (!response || response.ok() || !this.isTransientRiskControlStatus(statusCode)) {
+            return response;
+        }
+        try {
+            const followUpTimeout = Math.min(15000, Math.max(3000, (this.config.timeOut || 60) * 1000));
+            const followUpResponse = await this.page.waitForNavigation({
+                waitUntil: 'load',
+                timeout: followUpTimeout
+            });
+            return followUpResponse || response;
+        }
+        catch {
+            return response;
+        }
+    }
+    getErrorMessage(error) {
+        if (error instanceof Error) {
+            return error.message || error.toString();
+        }
+        return String(error);
+    }
+    async execute() {
+        var _a, _b;
+        try {
+            await this.clearCache();
+            await this.setCookies();
+            if (this.config.navigateType === "OpenJson" /* NavigateType.OpenJson */) {
+                const { requestMethod, requestHeaders, requestBodyContent, timeOut } = this.config;
+                const headers = new Map();
+                let extraHeaders = '';
+                for (const { name, value } of requestHeaders) {
+                    headers.set(name, value);
+                    extraHeaders += `${name}: ${value}\n`;
+                }
+                // 使用 jsonParser 发起 HTTP 请求并加载数据
+                // timeout 单位是毫秒
+                const timeoutMs = (timeOut || 60) * 1000;
+                await this.browserProxy.jsonParser.startRequest(this.url, requestMethod || 'GET', headers, requestBodyContent || '', timeoutMs);
+            }
+            else {
+                // 拦截cloudflare
+                if (this.isAutoCloudflare) {
+                    // 打开网页之前注入代码
+                    await this.setupTurnstileInterceptor();
+                }
+                const [, response] = await Promise.all([
+                    this.page.waitForNavigation({
+                        waitUntil: 'load',
+                        timeout: this.config.timeOut * 1000 || 60000
+                    }),
+                    this.page.goto(this.url, {
+                        waitUntil: 'load',
+                        timeout: this.config.timeOut * 1000 || 60000
+                    })
+                ]);
+                const finalResponse = await this.resolveFinalNavigationResponse(response);
+                const statusText = ' status = ' + ((_a = finalResponse === null || finalResponse === void 0 ? void 0 : finalResponse.status) === null || _a === void 0 ? void 0 : _a.call(finalResponse));
+                // 检查是否被风控
+                const statusCode = (_b = finalResponse === null || finalResponse === void 0 ? void 0 : finalResponse.status) === null || _b === void 0 ? void 0 : _b.call(finalResponse);
+                const isLoadFailed = !(finalResponse === null || finalResponse === void 0 ? void 0 : finalResponse.ok());
+                // 保存页面加载状态到 BrowserProxy
+                this.browserProxy.pageLoadStatus = {
+                    url: this.url,
+                    statusCode,
+                    isLoadFailed,
+                    timestamp: Date.now()
+                };
+                if (statusCode &&
+                    !/^[123]/.test(statusCode.toString()) &&
+                    statusCode.toString() !== '404') {
+                    this.debug('RiskControlBlocked', `httpErrorStatus=${statusCode}`);
+                    this.collectProxyLog(`[${this.name}] RiskControlBlocked httpErrorStatus=${statusCode}`, false);
+                }
+                if (finalResponse && finalResponse.ok()) {
+                    this.log(enums_1.LogKey.Navigate.Goto.Loading, this.name, this.url);
+                    await this.onPageLoaded(this.page.url() + statusText);
+                }
+                else {
+                    this.error(enums_1.LogKey.Navigate.Goto.Failure, this.name, this.url + statusText);
+                    /** 上传代理IP失败的接口 */
+                    this.collectProxyLog(`[${this.name}] Failed to load webpage,page=${this.url} status=${statusText}`, false);
+                    await this.retry();
+                }
+                await this.fixCloudflare();
+                await this.checkPause();
+                // await this.scroll()
+            }
+        }
+        catch (error) {
+            const errorMessage = this.getErrorMessage(error);
+            const isTimeout = /timeout/i.test(errorMessage);
+            await this.checkPause();
+            // 保存页面加载失败状态到 BrowserProxy
+            this.browserProxy.pageLoadStatus = {
+                url: this.url,
+                statusCode: undefined,
+                isLoadFailed: true,
+                error: errorMessage,
+                timestamp: Date.now()
+            };
+            if (isTimeout) {
+                this.error(enums_1.LogKey.Navigate.Error.Timeout, this.name, this.page.url());
+                console.log('打开网页超时', error, this.retryIsNeed);
+                this.collectProxyLog(`[${this.name}] Page load timeout,page=${this.url} error=${errorMessage}`, false);
+            }
+            else {
+                this.error(enums_1.LogKey.Navigate.Goto.Failure, this.name, `${this.url} error = ${errorMessage}`);
+                console.log('打开网页失败', error, this.retryIsNeed);
+                this.collectProxyLog(`[${this.name}] Page load failed,page=${this.url} error=${errorMessage}`, false);
+            }
+            this.retryIsNeed = false;
+        }
+        finally {
+            if (!this.retryIsNeed) {
+                this.finish();
+            }
+        }
+    }
+    /** 清理当前网站的缓存 */
+    async clearCache() {
+        // JSON 任务不需要清除浏览器缓存
+        if (this.config.navigateType === "OpenJson" /* NavigateType.OpenJson */) {
+            return;
+        }
+        if (this.config.clearCache) {
+            // 清除缓存
+            const client = await this.page.createCDPSession();
+            await client.send('Network.clearBrowserCache');
+            // 清除cookie
+            const context = this.getContext();
+            const allCookies = await context.cookies();
+            await context.deleteCookie(...allCookies);
+            this.log(enums_1.LogKey.Navigate.ClearCache.Success, this.name);
+        }
+    }
+    /** 设置已保存的 Cookies */
+    async setCookies() {
+        // context.setCookie()
+        const url = (0, utils_1.correctUrl)(this.url);
+        /** 设置全局cookie */
+        if (this.browserProxy.isSetGlobalCookie) {
+            if (this.browserProxy.globalCookie) {
+                const cookies = this.parseCookies(this.browserProxy.globalCookie, url);
+                if (this.config.navigateType == "OpenJson" /* NavigateType.OpenJson */) {
+                    //
+                }
+                else {
+                    const context = this.getContext();
+                    await context.setCookie(...cookies);
+                    this.log(enums_1.LogKey.GlobalCookies.Success, this.name);
+                }
+            }
+            else {
+                this.error(enums_1.LogKey.GlobalCookies.Failure, this.name);
+            }
+        }
+        /** 设置打开网页步骤指定cookie */
+        if (this.config.useCustomizeCookie) {
+            if (!this.config.customizeCookies ||
+                this.config.customizeCookies.length === 0) {
+                this.error(enums_1.LogKey.Navigate.Cookies.Failure, this.name);
+                return;
+            }
+            if (this.config.navigateType == "OpenJson" /* NavigateType.OpenJson */) {
+                // HttpRequester.cookies = this.config.customizeCookies
+            }
+            else {
+                const cookies = [];
+                for (const { name, value, path, host: domain, isHttpOnly: httpOnly, expiry: expirationDate } of this.config.customizeCookies) {
+                    const cookie = {
+                        name,
+                        value: `${value}`,
+                        path,
+                        domain,
+                        httpOnly,
+                        expires: expirationDate
+                    };
+                    cookies.push({
+                        ...cookie,
+                        domain: domain.startsWith('.') ? domain : '.' + domain
+                    });
+                    if (!this.browserProxy.cookiesRule.excludeSetTopDomainList.includes(domain)) {
+                        const items = domain.split('.');
+                        const domains = [items.pop()];
+                        while (items.length > 0) {
+                            domains.unshift(items.pop());
+                            const host = domains.join('.');
+                            if (host === domain) {
+                                break;
+                            }
+                            cookies.push({
+                                ...cookie,
+                                domain: host.startsWith('.') ? host : '.' + host
+                            });
+                        }
+                    }
+                }
+                const context = this.getContext();
+                await context.setCookie(...cookies);
+                this.log(enums_1.LogKey.Navigate.Cookies.Success, this.name);
+            }
+        }
+    }
+    /** 判定是否需要重试 */
+    async checkRetry() {
+        let isNeedRetry = false;
+        if (!this.config.enableRetry)
+            return isNeedRetry;
+        if (++this.retryTimes > this.config.maxRetry)
+            return isNeedRetry;
+        /** @todo 下面这三个判断逻辑在 8 版本里面应该是废弃了，待确定看是否可以删除 */
+        if (this.config.textContain) {
+            // this.log(LogKey.Common.Retry.Text.Found, this.name, this.config.textContain)
+            const args = new conditionCheckArgs_1.ConditionCheckArgs(this.config.textContain, "ContainText" /* RetryConditionType.ContainText */);
+            args.actionConfig = this.config;
+            args.navigateType = "OpenWebpage" /* NavigateType.OpenWebpage */;
+            isNeedRetry = await this.conditionCheck(args, this.page);
+        }
+        else if (this.config.textNotContain) {
+            // this.log(LogKey.Common.Retry.XPath.NotFound, this.name, this.config.textNotContain)
+            const args = new conditionCheckArgs_1.ConditionCheckArgs(this.config.textNotContain, "ContainText" /* RetryConditionType.ContainText */);
+            args.actionConfig = this.config;
+            args.navigateType = "OpenWebpage" /* NavigateType.OpenWebpage */;
+            isNeedRetry = !(await this.conditionCheck(args, this.page));
+        }
+        else if (this.config.urlContain) {
+            // this.log(LogKey.Common.Retry.URL.Found, this.name, this.config.urlContain)
+            const args = new conditionCheckArgs_1.ConditionCheckArgs(this.config.urlContain, "URLContain" /* RetryConditionType.URLContain */);
+            args.actionConfig = this.config;
+            args.navigateType = "OpenWebpage" /* NavigateType.OpenWebpage */;
+            isNeedRetry = await this.conditionCheck(args, this.page);
+        }
+        if (this.config.retryConditions && this.config.retryConditions.length > 0) {
+            const args = new conditionCheckArgs_1.ConditionCheckArgs(this.config.waitItem, "Multiple" /* RetryConditionType.Multiple */);
+            args.actionConfig = this.config;
+            args.navigateType = this.config.navigateType;
+            args.retryConditions = this.config.retryConditions;
+            isNeedRetry = await this.conditionCheck(args, this.page);
+        }
+        if (isNeedRetry)
+            this.log(enums_1.LogKey.Common.Retry.Success, this.name, this.config.retryInterval, this.retryTimes);
+        else
+            this.error(enums_1.LogKey.Common.Retry.Failure, this.name);
+        await this.checkPause();
+        return isNeedRetry;
+    }
+    parseCookies(cookieStr, correctUrl) {
+        const customizeCookies = [];
+        try {
+            if (!(0, utils_1.isNullOrEmpty)(cookieStr)) {
+                let url;
+                if (!(0, utils_1.isNullOrEmpty)(correctUrl)) {
+                    url = new URL(correctUrl);
+                }
+                const cookieLines = cookieStr.split(';');
+                cookieLines.forEach((l) => {
+                    const kv = l.split(/:|=/);
+                    // 存在特殊情况
+                    if (kv.length >= 2) {
+                        const cookie = { name: '', value: '', domain: '' };
+                        cookie.name = kv[0].trim();
+                        cookie.path = '/';
+                        cookie.domain = url === undefined ? '' : '.' + url.host;
+                        cookie.httpOnly = false;
+                        // 设置一个长的客户端的cookie过期时间，防止被浏览器认为无效
+                        cookie.expires = new Date().getTime() / 1000 + 3600 * 24 * 365;
+                        // cookie.sameSite = 'None'
+                        if (kv.length === 2) {
+                            cookie.value = kv[1].trim();
+                        }
+                        else {
+                            const ind = l.indexOf('=');
+                            cookie.value = l.substring(ind + 1);
+                        }
+                        customizeCookies.push(cookie);
+                        const items = cookie.domain.split('.');
+                        const domains = [items.pop()];
+                        while (items.length > 0) {
+                            domains.unshift(items.pop());
+                            const host = domains.join('.');
+                            if (host === cookie.domain) {
+                                break;
+                            }
+                            customizeCookies.push({ ...cookie, domain: '.' + host });
+                        }
+                    }
+                });
+            }
+        }
+        catch (error) {
+            // this.workflow.error(LogKey.GlobalCookies.Failure, this.name)
+        }
+        return customizeCookies;
+    }
+    start() {
+        if (!this.getIsSkipCurrentLoop() ||
+            !this.getIsSkipActionUtilNextLoop(this.getNodeId())) {
+            // const currentIndex = this.workflow.browser.getCurrentPageIndex()
+            // currentIndex === -1 && this.workflow.browser.switchPage(this.config.pageIndex)
+        }
+    }
+    async wait() {
+        this.browserProxy.navigateURL = this.url;
+        if (this.config.navigateType === "OpenJson" /* NavigateType.OpenJson */) {
+            this.debug('JsonTask', 'json任务');
+        }
+        if (this.getIsSkipCurrentLoop() ||
+            this.getIsSkipActionUtilNextLoop(this.getNodeId())) {
+            this.finish();
+            return;
+        }
+        this.page = await this.getCurrentPage();
+        await this.checkPause();
+        if (this.config.navigateType !== "OpenJson" /* NavigateType.OpenJson */) {
+            await super.wait();
+        }
+        // 得到任务类型，赋值全局变量 todo
+        this.browserProxy.setNavigateType(this.config.navigateType);
+        if (this.config.useLoopItem) {
+            this.log(enums_1.LogKey.Navigate.BeginWithLoop, this.name);
+            this.url = this.getCurrentLoopValue();
+        }
+        else {
+            this.log(enums_1.LogKey.Navigate.Begin, this.name);
+            this.url = this.config.url;
+        }
+        // this.workflow.navigateURL = this.url
+        if (!this.url) {
+            this.error(enums_1.LogKey.Navigate.Error.NotFondURL, this.name);
+            this.finish();
+            return;
+        }
+        this.execute();
+    }
+    onPageLoading(url) {
+        if (!this.activity.waiting)
+            return;
+        if (this.config.navigateType === "OpenJson" /* NavigateType.OpenJson */)
+            return;
+        // this.log(LogKey.Navigate.Goto.Loading, this.name, url)
+    }
+    async onPageLoaded(url) {
+        if (!this.activity.waiting)
+            return;
+        if (this.config.navigateType === "OpenJson" /* NavigateType.OpenJson */)
+            return;
+        this.log(enums_1.LogKey.Navigate.Goto.Success, this.name, url);
+        /**
+         * 只上传一次
+         */
+        if (!this.browserProxy.isUploadedProxyInfoOpenedPage) {
+            this.collectProxyLog(`[${this.name}] Success load webpage,page=${this.url}`, true);
+            this.browserProxy.isUploadedProxyInfoOpenedPage = true;
+        }
+        await this.checkPause();
+        await this.waitRequest();
+        const isNeedRetry = await this.retry();
+        if (isNeedRetry) {
+            return;
+        }
+        await this.scroll();
+    }
+    async retry() {
+        const isNeedRetry = await this.checkRetry();
+        this.retryIsNeed = isNeedRetry;
+        if (isNeedRetry) {
+            if (this.config.retryInterval > 0) {
+                await this.sleep(this.config.retryInterval * 1000);
+                await this.checkPause();
+            }
+            await this.switchIP(this.page);
+            this.switchUA();
+            this.execute();
+            return isNeedRetry;
+        }
+    }
+    async fixCloudflare() {
+        // 暂时先走刷新的方式拦截cloudflare
+        // 这里卡了太长时间，后面继续优化
+        // 刷新网页最多三次
+        try {
+            if (!this.isAutoCloudflare)
+                return;
+            const hasTurnstile = await this.judgeHasTurnstile();
+            if (!hasTurnstile)
+                return;
+            let retryGetParamsTimes = 0;
+            const maxRetryGetParamsTimes = 3;
+            let params = null;
+            while (!params && retryGetParamsTimes < maxRetryGetParamsTimes) {
+                await this.page.reload();
+                params = await this.page.evaluate(() => {
+                    return new Promise((resolve, reject) => {
+                        let checkTurnstileParamsI = 0;
+                        const checkTurnstileParamsTimer = setInterval(() => {
+                            if (window.turnstileFreezeParams) {
+                                clearInterval(checkTurnstileParamsTimer);
+                                resolve(window.turnstileFreezeParams);
+                            }
+                            checkTurnstileParamsI++;
+                            if (checkTurnstileParamsI >= 5) {
+                                clearInterval(checkTurnstileParamsTimer);
+                                resolve(null);
+                            }
+                        }, 1000);
+                    });
+                });
+                retryGetParamsTimes++;
+            }
+            if (params) {
+                this.resource(enums_1.LogKey.EnterCapacha.Begin, this.name);
+                this.resource(enums_1.LogKey.EnterCapacha.Action, this.name);
+                const token = await this.getCaptchaToken({
+                    ...params,
+                    captchaType: enums_1.LocalCaptchaType.Cloudflare
+                });
+                await this.page.evaluate((token) => {
+                    window.turnstileCallback && window.turnstileCallback(token);
+                }, token);
+                if (token) {
+                    this.resource(enums_1.LogKey.EnterCapacha.Complete, this.name);
+                }
+            }
+        }
+        catch (error) {
+            console.log('解决cloudflare验证码出错:', error);
+        }
+        return;
+    }
+    async judgeHasTurnstile() {
+        try {
+            const hasTurnstile = await this.page.evaluate(`
+        new Promise(resolve => {
+          const start = Date.now();
+          const check = () => !!window.turnstile;
+          if (check()) return resolve(true);
+          const interval = setInterval(() => {
+            if (check()) {
+              clearInterval(interval);
+              resolve(true);
+            } else if (Date.now() - start > 5000) {
+              clearInterval(interval);
+              resolve(false);
+            }
+          }, 100);
+        });
+        `);
+            return hasTurnstile;
+        }
+        catch (error) {
+            console.log('judgeHasTurnstile error', error);
+            return false;
+        }
+    }
+    async onJsonResponse() {
+        // this.log(LogKey.Navigate.Goto.Success, this.name, this.url)
+        await this.checkPause();
+        const isNeedRetry = await this.checkRetry();
+        if (isNeedRetry) {
+            if (this.config.retryInterval > 0) {
+                await this.sleep(this.config.retryInterval * 1000);
+                await this.checkPause();
+            }
+            await this.switchIP(this.page);
+            this.switchUA();
+            this.execute();
+            return;
+        }
+        this.finish();
+    }
+    onJsonError() {
+        // this.workflow.error(LogKey.Navigate.Goto.Failure, this.name, this.url)
+        this.finish();
+    }
+}
+exports.default = NavigateAction;

package/node_modules/@octopus/engine/dist/actions/SwitchComboAction.d.ts

@@ -0,0 +1,13 @@
+import SwitchComboConfig from '../configs/SwitchComboConfig';
+import BaseAction from './BaseAction';
+export default class SwitchComboAction extends BaseAction {
+    config: SwitchComboConfig;
+    private page;
+    protected parseConfig(config: Record<string, unknown>): SwitchComboConfig;
+    wait(): Promise<void>;
+    /**
+     * 使用项目通用方法processElement实现selectOptions功能
+     * 选择option元素并触发change事件
+     */
+    private selectOptions;
+}

package/node_modules/@octopus/engine/dist/actions/SwitchComboAction.js

@@ -0,0 +1,69 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const SwitchComboConfig_1 = __importDefault(require("../configs/SwitchComboConfig"));
+const enums_1 = require("../enums");
+const actionItem_1 = require("../models/actionItem");
+const BaseAction_1 = __importDefault(require("./BaseAction"));
+const Operations_1 = require("../utils/Operations");
+class SwitchComboAction extends BaseAction_1.default {
+    parseConfig(config) {
+        return new SwitchComboConfig_1.default(config);
+    }
+    async wait() {
+        if (this.getIsSkipCurrentLoop() || this.getIsSkipActionUtilNextLoop(this.getNodeId())) {
+            this.finish();
+            return;
+        }
+        await super.wait();
+        let actionItem = this.config.elementXPath;
+        if (this.config.useLoopItem) {
+            const { AbsXpath, IsIFrame, IFrameAbsXPath } = this.getCurrentLoopValue();
+            actionItem = new actionItem_1.ActionItem(AbsXpath + actionItem.AbsXpath, IsIFrame, IFrameAbsXPath);
+        }
+        this.log(enums_1.LogKey.SwitchCombo.Begin, this.name, actionItem.AbsXpath);
+        this.page = await this.getCurrentPage();
+        const timeout = (this.config.ajaxTimeout || 1.5) * 1000;
+        const [, select] = await Promise.allSettled([
+            this.page.waitForNetworkIdle({ timeout, idleTime: 300, concurrency: 3 }),
+            await this.selectOptions(actionItem),
+        ]);
+        if (select.status == 'rejected') {
+            console.log('select options error');
+            throw new Error(select.reason);
+        }
+        await this.ajax();
+        this.finish();
+    }
+    /**
+     * 使用项目通用方法processElement实现selectOptions功能
+     * 选择option元素并触发change事件
+     */
+    async selectOptions(actionItem) {
+        try {
+            await (0, Operations_1.processElement)(actionItem, this.page, '$eval', (element) => {
+                if (element && element.nodeName === 'OPTION') {
+                    element.selected = true;
+                    // 找到父级select元素
+                    let selectElement = element.parentElement;
+                    while (selectElement && selectElement.nodeName !== 'SELECT') {
+                        selectElement = selectElement.parentElement;
+                    }
+                    if (selectElement) {
+                        // 触发change事件
+                        const event = new Event('change', { bubbles: true });
+                        selectElement.dispatchEvent(event);
+                    }
+                }
+            });
+        }
+        catch (error) {
+            await this.checkPause();
+            console.error('选择选项时出错:', error.message);
+            throw error;
+        }
+    }
+}
+exports.default = SwitchComboAction;

package/node_modules/@octopus/engine/dist/browser.d.ts

@@ -0,0 +1,17 @@
+export interface ResolveStatus {
+    state: 'checking' | 'downloading' | 'retrying' | 'completed' | 'failed';
+    progress?: number;
+}
+export interface ChromeInstallConfig {
+    baseUrl: string;
+    buildId: string;
+    cacheDir?: string;
+}
+export interface ResolveOptions {
+    onStatus?: (status: ResolveStatus) => void;
+    installOptions?: ChromeInstallConfig;
+}
+export declare function cleanupChromeCache(installOptions?: ChromeInstallConfig): Promise<void>;
+export declare function resolveChrome(options?: ResolveOptions): Promise<{
+    executablePath: string;
+}>;