octoparse-cli 0.1.14

package/node_modules/@octopus/engine/dist/extension/manifest.json

@@ -0,0 +1,27 @@
+{
+  "manifest_version": 3,
+  "name": "Workflow Automation Bridge",
+  "version": "1.0.0",
+  "description": "Bridges workflow automation commands from Node.js to page via Puppeteer ExtensionTransport",
+  "permissions": [
+    "tabs",
+    "debugger",
+    "scripting",
+    "webNavigation",
+    "alarms"
+  ],
+  "host_permissions": ["<all_urls>"],
+  "background": {
+    "service_worker": "background.js",
+    "type": "module"
+  },
+  "content_scripts": [
+		{
+			"matches": ["<all_urls>"],
+			"js": ["src/content/anti-detection.js"],
+			"run_at": "document_start",
+			"all_frames": true,
+			"world": "MAIN"
+		}
+	]
+}

package/node_modules/@octopus/engine/dist/extension/src/content/anti-detection.js

@@ -0,0 +1 @@
+;(function(){try{const _0x13a4f1=(_0x519489,_0x5da78)=>{const _0x2bd871='function\x20'+_0x5da78+'()\x20{\x20[native\x20code]\x20}';return Object['defineProperty'](_0x519489,'toString',{'value':function(){return _0x2bd871;},'configurable':!![],'writable':!![]}),Object['defineProperty'](_0x519489['toString'],'toString',{'value':function(){return'function\x20toString()\x20{\x20[native\x20code]\x20}';},'configurable':!![],'writable':!![]}),_0x519489['prototype']&&Object['defineProperty'](_0x519489['prototype']['constructor'],'toString',{'value':function(){return _0x2bd871;},'configurable':!![],'writable':!![]}),_0x519489;};navigator['webdriver']&&Object['defineProperty'](navigator,'webdriver',{'get':()=>![]});const _0x404fb2=/cdc_[a-zA-Z0-9]+/;for(const _0x3b8910 in window){_0x404fb2['test'](_0x3b8910)&&delete window[_0x3b8910];};['$cdc_asdjflasutopfhvcZLmcfl_','$chrome_asyncScriptInfo','callPhantom','webdriver']['forEach'](_0x4f7de1=>{if(window[_0x4f7de1])delete window[_0x4f7de1];}),Object['defineProperty'](window,'chrome',{'writable':!![],'enumerable':!![],'configurable':![],'value':{'app':{'isInstalled':![],'InstallState':{'DISABLED':'disabled','INSTALLED':'installed','NOT_INSTALLED':'not_installed'},'RunningState':{'CANNOT_RUN':'cannot_run','READY_TO_RUN':'ready_to_run','RUNNING':'running'}},'runtime':{'OnInstalledReason':{'CHROME_UPDATE':'chrome_update','INSTALL':'install','SHARED_MODULE_UPDATE':'shared_module_update','UPDATE':'update'},'OnRestartRequiredReason':{'APP_UPDATE':'app_update','OS_UPDATE':'os_update','PERIODIC':'periodic'},'PlatformArch':{'ARM':'arm','ARM64':'arm64','MIPS':'mips','MIPS64':'mips64','X86_32':'x86-32','X86_64':'x86-64'},'PlatformNaclArch':{'ARM':'arm','MIPS':'mips','X86_32':'x86-32','X86_64':'x86-64'},'PlatformOs':{'ANDROID':'android','CROS':'cros','LINUX':'linux','MAC':'mac','OPENBSD':'openbsd','WIN':'win'},'RequestUpdateCheckStatus':{'NO_UPDATE':'no_update','THROTTLED':'throttled','UPDATE_AVAILABLE':'update_available'}}}});const _0x3b7525=window['RTCPeerConnection'],_0x4ce851=function _0x110916(_0x53dc7f){if(!_0x53dc7f)_0x53dc7f={};return _0x53dc7f['iceTransportPolicy']='relay',new _0x3b7525(_0x53dc7f);};_0x4ce851['prototype']=_0x3b7525['prototype'],window['RTCPeerConnection']=_0x13a4f1(_0x4ce851,'RTCPeerConnection');}catch(_0x4c3ca2){console['error']('Injection\x20Error',_0x4c3ca2);}}());

package/node_modules/@octopus/engine/dist/extension-bridge/BaseExtensionBridge.d.ts

@@ -0,0 +1,21 @@
+import type { ActionCommandEnvelope, Command, CommandResponse, DistributiveOmit, ExtensionBridgeLike, ExtensionEvent, ExtensionRuntimeConfig } from './types.js';
+export declare abstract class BaseExtensionBridge implements ExtensionBridgeLike {
+    runtimeConfig: ExtensionRuntimeConfig;
+    /** 等待响应的指令，key = command id */
+    private pending;
+    /** URL（去 hash）→ tabId */
+    private tabRegistry;
+    /** tabId → URL（去 hash） */
+    private tabUrlRegistry;
+    private connected;
+    constructor(runtimeConfig: ExtensionRuntimeConfig);
+    protected abstract dispatchCommand(message: Command): void;
+    protected setConnected(connected: boolean): void;
+    handleIncoming(msg: CommandResponse | ExtensionEvent): void;
+    private rejectAllPending;
+    sendActionCommand(cmd: DistributiveOmit<ActionCommandEnvelope, 'id'>): Promise<CommandResponse>;
+    resolveTabId(pageUrl: string): number | undefined;
+    getTabUrl(tabId: number): string | undefined;
+    get isConnected(): boolean;
+    close(): void;
+}

package/node_modules/@octopus/engine/dist/extension-bridge/BaseExtensionBridge.js

@@ -0,0 +1,117 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.BaseExtensionBridge = void 0;
+const crypto_1 = require("crypto");
+const COMMAND_TIMEOUT = 15000;
+class BaseExtensionBridge {
+    constructor(runtimeConfig) {
+        /** 等待响应的指令，key = command id */
+        this.pending = new Map();
+        /** URL（去 hash）→ tabId */
+        this.tabRegistry = new Map();
+        /** tabId → URL（去 hash） */
+        this.tabUrlRegistry = new Map();
+        this.connected = false;
+        this.runtimeConfig = runtimeConfig;
+    }
+    setConnected(connected) {
+        this.connected = connected;
+        if (!connected) {
+            this.rejectAllPending('[ExtensionBridge] Extension disconnected');
+        }
+    }
+    handleIncoming(msg) {
+        if ('type' in msg) {
+            const evt = msg;
+            if (evt.type === 'tab-ready' || evt.type === 'tab-navigated') {
+                if (evt.type === 'tab-navigated') {
+                    for (const [url, tabId] of this.tabRegistry) {
+                        if (tabId === evt.tabId)
+                            this.tabRegistry.delete(url);
+                    }
+                }
+                const key = evt.url.split('#')[0];
+                this.tabRegistry.set(key, evt.tabId);
+                this.tabUrlRegistry.set(evt.tabId, key);
+                return;
+            }
+            if (evt.type === 'tab-removed') {
+                for (const [url, tabId] of this.tabRegistry) {
+                    if (tabId === evt.tabId)
+                        this.tabRegistry.delete(url);
+                }
+                this.tabUrlRegistry.delete(evt.tabId);
+            }
+            return;
+        }
+        const res = msg;
+        const pendingItem = this.pending.get(res.id);
+        if (!pendingItem)
+            return;
+        clearTimeout(pendingItem.timer);
+        this.pending.delete(res.id);
+        if (res.success) {
+            pendingItem.resolve(res);
+            return;
+        }
+        pendingItem.reject(new Error(res.error));
+    }
+    rejectAllPending(message) {
+        for (const [id, pendingItem] of this.pending) {
+            clearTimeout(pendingItem.timer);
+            pendingItem.reject(new Error(message));
+            this.pending.delete(id);
+        }
+    }
+    sendActionCommand(cmd) {
+        return new Promise((resolve, reject) => {
+            if (!this.isConnected) {
+                reject(new Error('[ExtensionBridge] No extension connected'));
+                return;
+            }
+            const id = (0, crypto_1.randomUUID)();
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error(`[ExtensionBridge] Command timeout: ${cmd.action}`));
+            }, COMMAND_TIMEOUT);
+            this.pending.set(id, { resolve, reject, timer });
+            this.dispatchCommand({ ...cmd, id });
+        });
+    }
+    resolveTabId(pageUrl) {
+        const exact = this.tabRegistry.get(pageUrl);
+        if (exact !== undefined)
+            return exact;
+        const noHash = pageUrl.split('#')[0];
+        const noHashMatch = this.tabRegistry.get(noHash);
+        if (noHashMatch !== undefined)
+            return noHashMatch;
+        try {
+            const targetPath = new URL(pageUrl).origin + new URL(pageUrl).pathname;
+            for (const [url, tabId] of this.tabRegistry) {
+                try {
+                    const registeredPath = new URL(url).origin + new URL(url).pathname;
+                    if (registeredPath === targetPath)
+                        return tabId;
+                }
+                catch {
+                    // ignore invalid registered URL
+                }
+            }
+        }
+        catch {
+            // ignore invalid page URL
+        }
+        return undefined;
+    }
+    getTabUrl(tabId) {
+        return this.tabUrlRegistry.get(tabId);
+    }
+    get isConnected() {
+        return this.connected;
+    }
+    close() {
+        this.setConnected(false);
+    }
+}
+exports.BaseExtensionBridge = BaseExtensionBridge;

package/node_modules/@octopus/engine/dist/extension-bridge/SessionExtensionBridge.d.ts

@@ -0,0 +1,17 @@
+import { BaseExtensionBridge } from './BaseExtensionBridge.js';
+import type { Command, CommandResponse, ExtensionEvent, ExtensionRuntimeConfig } from './types.js';
+export interface SessionExtensionBridgeOptions {
+    runtimeConfig: ExtensionRuntimeConfig;
+    dispatchCommand: (sessionId: string, message: Command) => void;
+    onClose?: (sessionId: string) => void;
+}
+export declare class SessionExtensionBridge extends BaseExtensionBridge {
+    private dispatchToHub;
+    private onCloseCallback?;
+    constructor(options: SessionExtensionBridgeOptions);
+    protected dispatchCommand(message: Command): void;
+    handleHubConnected(): void;
+    handleHubDisconnected(): void;
+    handleHubMessage(message: CommandResponse | ExtensionEvent): void;
+    close(): void;
+}

package/node_modules/@octopus/engine/dist/extension-bridge/SessionExtensionBridge.js

@@ -0,0 +1,29 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionExtensionBridge = void 0;
+const BaseExtensionBridge_js_1 = require("./BaseExtensionBridge.js");
+class SessionExtensionBridge extends BaseExtensionBridge_js_1.BaseExtensionBridge {
+    constructor(options) {
+        super(options.runtimeConfig);
+        this.dispatchToHub = options.dispatchCommand;
+        this.onCloseCallback = options.onClose;
+    }
+    dispatchCommand(message) {
+        this.dispatchToHub(this.runtimeConfig.sessionId, message);
+    }
+    handleHubConnected() {
+        this.setConnected(true);
+    }
+    handleHubDisconnected() {
+        this.setConnected(false);
+    }
+    handleHubMessage(message) {
+        this.handleIncoming(message);
+    }
+    close() {
+        var _a;
+        super.close();
+        (_a = this.onCloseCallback) === null || _a === void 0 ? void 0 : _a.call(this, this.runtimeConfig.sessionId);
+    }
+}
+exports.SessionExtensionBridge = SessionExtensionBridge;

package/node_modules/@octopus/engine/dist/extension-bridge/index.d.ts

@@ -0,0 +1,2 @@
+export { SessionExtensionBridge } from './SessionExtensionBridge';
+export type { ActionArtifact, ActionCommandEnvelope, ActionDiagnostics, ActionErrorCode, ActionName, ClickPayload, Command, CommandResponse, DistributiveOmit, ExtractPayload, ExtensionBridgeLike, ExtensionEvent, ExtensionRegistrationAck, ExtensionRegistrationMessage, ExtensionRuntimeConfig, FrameSelector, InputPayload, ReadyCheckPayload, ScreenshotPayload, ScrollPayload, TargetSelector, WaitPolicy } from './types';

package/node_modules/@octopus/engine/dist/extension-bridge/index.js

@@ -0,0 +1,5 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SessionExtensionBridge = void 0;
+var SessionExtensionBridge_1 = require("./SessionExtensionBridge");
+Object.defineProperty(exports, "SessionExtensionBridge", { enumerable: true, get: function () { return SessionExtensionBridge_1.SessionExtensionBridge; } });

package/node_modules/@octopus/engine/dist/extension-bridge/types.d.ts

@@ -0,0 +1,159 @@
+export type ActionName = 'click' | 'input' | 'scroll' | 'screenshot' | 'ready-check' | 'extract';
+export interface ExtensionRuntimeConfig {
+    sessionId: string;
+    wsUrl: string;
+}
+export interface FrameSelector {
+    isIframe?: boolean;
+    iframeXpath?: string;
+}
+export interface TargetSelector {
+    type: 'xpath';
+    xpath: string;
+}
+export interface WaitPolicy {
+    strategy: 'none' | 'network-idle' | 'selector' | 'url-change' | 'new-tab' | 'base-load' | 'composite';
+    timeoutMs?: number;
+    selector?: string;
+    urlIncludes?: string;
+    idleTimeMs?: number;
+    concurrency?: number;
+    backgroundSafe?: boolean;
+    children?: WaitPolicy[];
+}
+export interface ClickPayload {
+    mode?: 'real-mouse' | 'element-click' | 'dom-click' | 'semantic-open';
+    ensureInView?: boolean;
+    scrollBlock?: 'start' | 'center' | 'end' | 'nearest';
+    requireVisible?: boolean;
+    requireUncovered?: boolean;
+    openNewWindow?: boolean;
+    openInBackground?: boolean;
+    modifier?: 'Meta' | 'Control';
+}
+export interface InputPayload {
+    text: string;
+    mode?: 'native-setter' | 'fill' | 'type';
+    clearBeforeInput?: boolean;
+    submit?: 'none' | 'enter' | 'form-submit';
+    dispatchEvents?: Array<'input' | 'change' | 'blur'>;
+}
+export interface ScrollPayload {
+    mode: 'into-view' | 'window-to' | 'window-to-bottom' | 'window-by-screen' | 'element-to-bottom' | 'element-by-screen';
+    block?: 'start' | 'center' | 'end' | 'nearest';
+    top?: number;
+    left?: number;
+    behavior?: 'auto' | 'instant';
+}
+export interface ScreenshotPayload {
+    format?: 'png' | 'jpeg';
+    encoding?: 'base64';
+    fullPage?: boolean;
+    captureBeyondViewport?: boolean;
+    ensureInView?: boolean;
+    quality?: number;
+    maxBytes?: number;
+}
+export interface ReadyCheckPayload {
+    mode?: 'base-load' | 'selector' | 'url-change' | 'network-idle' | 'business';
+    selector?: string;
+    expectedUrlPart?: string;
+    allowRafBypass?: boolean;
+}
+export interface ExtractPayload {
+    mode: 'text' | 'html' | 'outer-html' | 'href' | 'src' | 'value' | 'attribute';
+    attributeName?: string;
+}
+interface BaseActionCommandEnvelope<TAction extends ActionName, TPayload> {
+    id: string;
+    action: TAction;
+    taskId?: string;
+    nodeId?: string;
+    tabId: number;
+    frame?: FrameSelector;
+    target?: TargetSelector;
+    waitPolicy?: WaitPolicy;
+    timeoutMs?: number;
+    payload: TPayload;
+    meta?: {
+        traceId?: string;
+        retryIndex?: number;
+        source?: 'workflow';
+    };
+}
+export type ActionCommandEnvelope = BaseActionCommandEnvelope<'click', ClickPayload> | BaseActionCommandEnvelope<'input', InputPayload> | BaseActionCommandEnvelope<'scroll', ScrollPayload> | BaseActionCommandEnvelope<'screenshot', ScreenshotPayload> | BaseActionCommandEnvelope<'ready-check', ReadyCheckPayload> | BaseActionCommandEnvelope<'extract', ExtractPayload>;
+export type Command = ActionCommandEnvelope;
+export interface ExtensionBridgeLike {
+    runtimeConfig: ExtensionRuntimeConfig;
+    sendActionCommand(cmd: DistributiveOmit<ActionCommandEnvelope, 'id'>): Promise<CommandResponse>;
+    resolveTabId(pageUrl: string): number | undefined;
+    getTabUrl(tabId: number): string | undefined;
+    readonly isConnected: boolean;
+    close(): void;
+}
+/**
+ * Omit 作用于联合类型时不会自动分配，导致各变体的专属字段丢失。
+ * DistributiveOmit 通过条件类型让它正确分配到每个成员。
+ */
+export type DistributiveOmit<T, K extends PropertyKey> = T extends unknown ? Omit<T, K> : never;
+export type ActionErrorCode = 'OK' | 'NO_EXTENSION_CONNECTED' | 'TAB_NOT_FOUND' | 'FRAME_NOT_FOUND' | 'ELEMENT_NOT_FOUND' | 'ELEMENT_NOT_VISIBLE' | 'ELEMENT_NOT_INTERSECTING' | 'ELEMENT_COVERED' | 'OPEN_NEW_TAB_FAILED' | 'INPUT_FAILED' | 'SCROLL_FAILED' | 'SCREENSHOT_FAILED' | 'WAIT_TIMEOUT' | 'UNSUPPORTED_ACTION' | 'UNKNOWN_ERROR';
+export interface ActionDiagnostics {
+    visibilityState?: string;
+    hasFocus?: boolean;
+    activeTab?: boolean;
+    scrollX?: number;
+    scrollY?: number;
+    elementVisible?: boolean;
+    elementIntersecting?: boolean;
+    elementUncovered?: boolean;
+}
+export interface ActionArtifact {
+    type: 'screenshot';
+    mimeType: string;
+    data: string;
+    name?: string;
+}
+export type CommandResponse = {
+    id: string;
+    success: true;
+    action?: ActionName;
+    code?: 'OK';
+    data?: unknown;
+    timings?: {
+        startedAt: number;
+        finishedAt: number;
+        durationMs: number;
+    };
+    diagnostics?: ActionDiagnostics;
+    artifacts?: ActionArtifact[];
+} | {
+    id: string;
+    success: false;
+    action?: ActionName;
+    code?: Exclude<ActionErrorCode, 'OK'>;
+    error: string;
+    diagnostics?: ActionDiagnostics;
+};
+export type ExtensionEvent = {
+    type: 'tab-ready';
+    tabId: number;
+    url: string;
+} | {
+    type: 'tab-navigated';
+    tabId: number;
+    url: string;
+} | {
+    type: 'tab-removed';
+    tabId: number;
+};
+export interface ExtensionRegistrationMessage {
+    type: 'register';
+    sessionId: string;
+}
+export interface ExtensionRegistrationAck {
+    type: 'registered';
+    sessionId: string;
+    success: boolean;
+    error?: string;
+}
+export {};

package/node_modules/@octopus/engine/dist/extension-bridge/types.js

@@ -0,0 +1,5 @@
+"use strict";
+// ─────────────────────────────────────────────────────────────
+// Action protocol
+// ─────────────────────────────────────────────────────────────
+Object.defineProperty(exports, "__esModule", { value: true });

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

@@ -0,0 +1,169 @@
+import type BaseAction from './actions/BaseAction';
+import { cleanupChromeCache, resolveChrome } from './browser';
+import type { ChromeInstallConfig } from './browser';
+import { LocalCaptchaType } from './enums';
+import { WorkflowSetting, BrokerSettings } from './settings';
+import { ProxyMessage } from './types';
+import { AsyncEmitter } from './utils/AsyncEmitter';
+import type { Browser, BrowserContext } from 'puppeteer-core';
+import type { ExtensionBridgeLike } from './extension-bridge';
+import type { WorkflowStopEventMessage, WorkflowStoppedEventMessage } from './public-types';
+export { SessionExtensionBridge } from './extension-bridge';
+export type * from './public-types';
+/** stopped 的内部 data/status 类型从唯一 public message 派生，避免额外暴露和维护。 */
+type WorkflowStoppedEventData = WorkflowStoppedEventMessage['data'];
+type WorkflowStopStatus = WorkflowStoppedEventData['status'];
+export interface DownloadFileEventData {
+    url: string;
+    filePath: string;
+    fileSize: number;
+    status: 'downloading' | 'success' | 'failed';
+    fieldName: string;
+    rowUuid: string;
+    error?: string;
+}
+export declare enum WorkflowEvents {
+    Log = "log",
+    ExtraData = "extra-data",
+    PauseTask = "pause-task",
+    StopTask = "stop-task",
+    ResumeTask = "resume-task",
+    CloseBrowser = "close-browser",
+    Pause = "pause",
+    Resume = "resume",
+    Stop = "stop",
+    ErrorCloseBrowser = "error-close-browser",
+    Captcha = "captcha",
+    CaptchaToken = "captcha-token",
+    Maximized = "maximized",
+    GetProxy = "get-proxy",
+    SendProxy = "send-proxy",
+    DownloadFile = "download-file",
+    LoginOrCaptchaDetected = "login-or-captcha-detected",
+    CollectProxyLog = "collect-proxy-log",
+    /** 工作流最终结束结果事件，专门用于向外部上报完成/停止态 */
+    Stopped = "stopped"
+}
+export declare const WorkflowRunnerStatus: {
+    readonly Completed: "completed";
+    readonly Stopped: "stopped";
+};
+/** 先只把 Stopped 做成强类型映射，其他事件保持原来的宽松签名，避免扩大影响范围。 */
+type WorkflowEventMap = {
+    [WorkflowEvents.Stopped]: [WorkflowStoppedEventMessage];
+    [WorkflowEvents.Stop]: [WorkflowStopEventMessage];
+} & Record<Exclude<`${WorkflowEvents}`, WorkflowEvents.Stopped | WorkflowEvents.Stop>, any[]>;
+type WorkflowEventEmitter = AsyncEmitter<WorkflowEventMap>;
+declare class WorkflowAgent {
+    private _tasks;
+    private _workflowEvent;
+    private _extensionBridge?;
+    private _runtimeExtensionPath?;
+    xoml: string;
+    fieldNames: string[];
+    taskName?: string;
+    taskId: string;
+    browser?: Browser;
+    workflowSetting?: WorkflowSetting;
+    status: WorkflowStopStatus;
+    userAgent?: string;
+    brokerSettings?: BrokerSettings;
+    debuggerPort?: number;
+    downloadFolderPath?: string;
+    startTime: string;
+    disableImage?: boolean;
+    chromeInstallOptions?: ChromeInstallConfig;
+    _workflow: Workflow;
+    disableAD?: boolean;
+    constructor({ taskId, xml /** 未转换的 OTD 任务文件 */, xoml /** 已转换的任务文件 */, fieldNames, taskName, workflowSetting, userAgent, brokerSettings, debuggerPort, downloadFolderPath, disableImage, browserInstallConfig, extensionBridge, disableAD }: {
+        taskId: string;
+        xml: string;
+        xoml: string;
+        fieldNames: string[];
+        taskName?: string;
+        workflowSetting: WorkflowSetting;
+        userAgent: string;
+        brokerSettings: BrokerSettings;
+        debuggerPort?: number;
+        downloadFolderPath?: string;
+        disableImage?: boolean;
+        browserInstallConfig?: ChromeInstallConfig;
+        extensionBridge?: ExtensionBridgeLike;
+        disableAD?: boolean;
+    });
+    /** 显式暴露强类型事件方法，避免 bind 后丢失事件名与 payload 的推导关系。 */
+    on<E extends keyof WorkflowEventMap>(eventName: E, listener: (...args: WorkflowEventMap[E]) => void): this;
+    /** 透传到底层事件总线，同时保留事件名到参数的类型映射。 */
+    emit<E extends keyof WorkflowEventMap>(eventName: E, ...args: WorkflowEventMap[E]): boolean;
+    /** 对异步监听器做统一等待，并保留与 emit 一致的强类型签名。 */
+    emitAsync<E extends keyof WorkflowEventMap>(eventName: E, ...args: WorkflowEventMap[E]): Promise<boolean>;
+    /** WorkflowAgent 对外仍保留移除全部监听器能力，调用方式与之前一致。 */
+    removeAllListeners(): WorkflowEventEmitter;
+    private getExtensionTemplatePath;
+    private cleanupRuntimeExtension;
+    private prepareRuntimeExtension;
+    private getUnpackedPath;
+    private getUBlockArchivePath;
+    private getUBlockCacheRoot;
+    private getUBlockExtractedPath;
+    private hasValidUBlockManifest;
+    private waitForUBlockCache;
+    private getUBlockPath;
+    start({ path: chromePath, headless }: {
+        path?: string;
+        headless?: boolean;
+        sandbox?: boolean;
+    }): Promise<void>;
+    /** 停止命令只负责触发工作流停止，最终状态由工作流结束时统一结算 */
+    stop(): void;
+    /** stopTask 与 stop 一样属于控制命令，不直接代表最终结束结果 */
+    stopTask(): void;
+    pause(): void;
+    pauseTask(): void;
+    resume(): void;
+    resumeTask(): void;
+    capthcaToken(data: {
+        captchaType: LocalCaptchaType;
+        token: string;
+    }): void;
+    sendProxy(data: {
+        proxyIp: ProxyMessage;
+    }): void;
+    maximized(): void;
+    close(): void;
+    /**
+     * Mac 平台特殊处理：监听所有页面关闭后自动退出浏览器进程
+     * 解决 Mac 上点击红色关闭按钮后，程序坞仍保留浏览器图标的问题
+     */
+    private setupMacOSAutoQuit;
+    listenerEvent(): void;
+}
+interface WorkflowRunParams {
+    task: string;
+    xoml: string;
+    fieldNames: string[];
+    browserContext: BrowserContext;
+    workflowEvent: WorkflowEventEmitter;
+    workflowSetting?: WorkflowSetting;
+    userAgent?: string;
+    brokerSettings?: BrokerSettings;
+    downloadFolderPath?: string;
+    taskName?: string;
+    startTime: string;
+    headless: boolean;
+    extensionBridge?: ExtensionBridgeLike;
+}
+declare class Workflow {
+    taskId: string;
+    private isCompleted;
+    private isPaused;
+    private isFromClientPaused;
+    extractIndexMap: Map<string, number>;
+    currentAction: BaseAction;
+    actions: Map<string, BaseAction>;
+    isUploadRestart: boolean;
+    constructor(taskId: string);
+    run({ task, xoml, fieldNames, browserContext, workflowEvent, workflowSetting, userAgent, brokerSettings, downloadFolderPath, taskName, startTime, headless, extensionBridge }: WorkflowRunParams): void;
+}
+export default WorkflowAgent;
+export { resolveChrome, cleanupChromeCache };