octoparse-cli 0.1.14

package/node_modules/@octopus/bpmn/lib/tasks/SubProcess.js

@@ -0,0 +1,17 @@
+'use strict';
+
+const BaseProcess = require('../activities/BaseProcess');
+
+function SubProcess() {
+  BaseProcess.apply(this, arguments);
+  this.isSubProcess = true;
+}
+
+SubProcess.prototype = Object.create(BaseProcess.prototype);
+
+SubProcess.prototype.run = function(message) {
+  const input = this.getInput(message);
+  return BaseProcess.prototype.run.call(this, input);
+};
+
+module.exports = SubProcess;

package/node_modules/@octopus/bpmn/lib/tasks/Task.js

@@ -0,0 +1,16 @@
+'use strict';
+
+const BaseTask = require('../activities/BaseTask');
+
+function Task() {
+  BaseTask.apply(this, arguments);
+}
+
+Task.prototype = Object.create(BaseTask.prototype);
+
+Task.prototype.execute = function(message) {
+  this.emit('start', this);
+  this.complete(message);
+};
+
+module.exports = Task;

package/node_modules/@octopus/bpmn/lib/tasks/UserTask.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const BaseTask = require('../activities/BaseTask');
+
+function UserTask() {
+  BaseTask.apply(this, arguments);
+  this._debug(`<${this.id}> ${this.uuid}`, 'init');
+  this.form = this.parentContext.getActivityForm(this.activity);
+}
+
+UserTask.prototype = Object.create(BaseTask.prototype);
+
+UserTask.prototype.execute = function(message) {
+  this._debug(`<${this.id}>`, 'execute');
+  if (this.form) {
+    this.form.init(this.getInput(message));
+  }
+
+  this.emit('start', this);
+  this.waiting = true;
+  this.emit('wait', this);
+};
+
+UserTask.prototype.signal = function(input) {
+  if (!this.waiting) {
+    return this.emit('error', new Error(`<${this.id}> is not waiting`), this);
+  }
+
+  this.waiting = false;
+
+  this.dataOutput = input;
+  this.taken = true;
+
+  this._debug(`<${this.id}>`, 'signaled', input);
+  this.complete(input);
+};
+
+UserTask.prototype.getState = function() {
+  const state = BaseTask.prototype.getState.call(this);
+  if (this.waiting) state.waiting = this.waiting;
+  if (this.form) {
+    state.form = this.form.getState();
+  }
+  return state;
+};
+
+module.exports = UserTask;

package/node_modules/@octopus/bpmn/lib/transformer.js

@@ -0,0 +1,13 @@
+'use strict';
+
+const BpmnModdle = require('bpmn-moddle');
+
+const pub = {};
+
+pub.transform = function(sourceXml, options, callback) {
+  if (!sourceXml || typeof sourceXml !== 'string') return callback(new Error('Nothing to transform'));
+  const moddle = new BpmnModdle(options);
+  return moddle.fromXML(sourceXml, callback);
+};
+
+module.exports = pub;

package/node_modules/@octopus/bpmn/lib/validation.js

@@ -0,0 +1,111 @@
+'use strict';
+
+const contextHelper = require('./context-helper');
+const debug = require('debug')('bpmn-engine:validation');
+
+const validExecuteOptions = ['listener', 'services', 'variables'];
+
+const pub = {};
+
+pub.validateModdleContext = function(moddleContext) {
+  if (!moddleContext) {
+    return [new Error('Nothing to validate')];
+  }
+  debug('validate start');
+  if (moddleContext.warnings && moddleContext.warnings.length) {
+    return moddleContext.warnings.map(makeErrors);
+  }
+
+  let warnings = moddleContext.warnings || [];
+  warnings = validateContext(moddleContext, warnings);
+
+  return warnings;
+};
+
+pub.validateOptions = function(options) {
+  if (!options) return true;
+
+  Object.keys(options).forEach((key) => {
+    if (validExecuteOptions.indexOf(key) === -1) throw new Error(`Execute option ${key} is unsupported`);
+  });
+
+  if (options.listener && typeof options.listener.emit !== 'function') {
+    throw new Error('listener "emit" function is required');
+  }
+  if (options.services) {
+    if (typeof options.services !== 'object') throw new Error('services must be an object');
+    validateServices(options.services);
+  }
+  if (options.variables) {
+    if (typeof options.variables !== 'object') throw new Error('variables must be an object');
+  }
+  return true;
+};
+
+function validateContext(context, warnings) {
+  Object.keys(context.elementsById).forEach((id) => {
+    const element = context.elementsById[id];
+    if (element.$type === 'bpmn:SequenceFlow') {
+      validateFlow(context, warnings, id, element);
+    } else if (element.$type === 'bpmn:ExclusiveGateway') {
+      const flows = contextHelper.getOutboundSequenceFlows(context, element.id);
+      if (!flows.length) {
+        warnings.push(new Error(`${element.$type} <${element.id}> has no outgoing flow`));
+      } else if (flows.length === 1) {
+        const flowElement = flows[0].element;
+        if (flowElement.conditionExpression) {
+          warnings.push(new Error(`${element.$type} <${element.id}> has a single diverging flow (${flowElement.$type} <${flowElement.id}>) with a condition`));
+        }
+      } else {
+        flows.forEach((flow) => {
+          const flowElement = flow.element;
+
+          if (!contextHelper.isDefaultSequenceFlow(context, flowElement.id) && !flowElement.conditionExpression) {
+            warnings.push(new Error(`${element.$type} <${element.id}> diverging flow (${flowElement.$type} <${flowElement.id}>) has no condition`));
+          }
+        });
+      }
+    }
+  });
+
+  if (warnings.length) {
+    debug(warnings[0].message);
+  }
+
+  debug('validate context end');
+
+  return warnings;
+}
+
+function validateFlow(context, warnings, id, element) {
+  const refs = context.references.filter((r) => r.element.id === id);
+
+  ['sourceRef', 'targetRef'].forEach((prop) => {
+    if (!refs.find((r) => r.property === `bpmn:${prop}`)) {
+      warnings.push(new Error(`${element.$type} <${element.id}> property "${prop}" is required`));
+    }
+  });
+}
+
+function validateServices(services) {
+  Object.keys(services).forEach((name) => {
+    const service = services[name];
+    if (!service) throw new Error(`Service "${name}" is undefined`);
+
+    const serviceType = typeof service;
+    if (['function', 'object'].indexOf(serviceType) === -1) throw new Error(`Service "${name}" is not a function or an object`);
+    if (serviceType === 'function') return;
+
+    if (!service.module || typeof service.module !== 'string') throw new Error(`Service "${name}" module must be a string`);
+    if (service.type && ['require', 'global'].indexOf(service.type) === -1) throw new Error(`Service "${name}" type <${service.type}> must be global or require`);
+  });
+}
+
+function makeErrors(eObj) {
+  const clone = Object.assign({}, eObj);
+  const err = new Error(clone.message);
+  delete clone.message;
+  return Object.assign(err, clone);
+}
+
+module.exports = pub;

package/node_modules/@octopus/bpmn/package.json

@@ -0,0 +1,17 @@
+{
+  "name": "@octopus/bpmn",
+  "version": "1.0.4",
+  "description": "BPMN 2.0 execution engine. Open source javascript workflow engine.",
+  "author": "octopus",
+  "main": "index.js",
+  "types": "types/bpmn.d.ts",
+  "engines": {
+    "node": ">=4"
+  },
+  "files": [
+    "lib",
+    "types",
+    "index.js"
+  ],
+  "dependencies": {}
+}

package/node_modules/@octopus/bpmn/types/bpmn.d.ts

@@ -0,0 +1,85 @@
+declare module "@octopus/bpmn" {
+  export class Definition {
+    constructor(moddleContext: any, options: any);
+
+    execute(optionsOrCallback: any, callback: any): any;
+
+    getChildActivityById(childId: any): any;
+
+    getPendingActivities(): any;
+
+    getProcessById(processId: any): any;
+
+    getProcesses(optionsOrCallback: any, callback: any): any;
+
+    getState(): any;
+
+    onEnd(process: any): void;
+
+    onError(...args: any[]): void;
+
+    onMessage(from: any, message: any, via: any): void;
+
+    signal(activityId: any, output: any): any;
+
+    stop(): void;
+
+    static resume(
+      state: any,
+      optionsOrCallback: any,
+      callback: any,
+      ...args: any[]
+    ): any;
+  }
+
+  export class Engine {
+    constructor(options: any);
+
+    addDefinitionByModdleContext(moddleContext: any): any;
+
+    addDefinitionBySource(
+      source: any,
+      moddleOptionsOrCallback: any,
+      callback: any
+    ): any;
+
+    execute(executeOptionsOrCallback: any, callback: any, ...args: any[]): any;
+
+    getDefinition(callback: any): any;
+
+    getDefinitionById(definitionId: any): any;
+
+    getDefinitions(callback: any): any;
+
+    getPendingActivities(): any;
+
+    getState(): any;
+
+    onEnd(lastReportingDefinition: any): void;
+
+    onError(...args: any[]): void;
+
+    signal(activityId: any, output: any): any;
+
+    stop(): void;
+
+    static resume(
+      engineState: any,
+      executeOptionsOrCallback: any,
+      callback: any,
+      ...args: any[]
+    ): any;
+
+    started?: boolean;
+  }
+
+  export namespace transformer {
+    function transform(sourceXml: any, options: any, callback: any): any;
+  }
+
+  export namespace validation {
+    function validateModdleContext(moddleContext: any): any;
+
+    function validateOptions(options: any): any;
+  }
+}

package/node_modules/@octopus/engine/README.md

@@ -0,0 +1,370 @@
+# Octopus Workflow - 智能数据采集流程引擎
+
+## 概述
+
+`@octopus/engine` 是一个基于浏览器自动化的智能数据采集流程引擎，专为 Octoparse 数据采集工具设计。该模块通过真实浏览器环境执行复杂的数据采集任务，支持页面导航、元素点击、数据提取、循环遍历等多种操作，实现高度灵活的自动化数据采集。
+
+## 技术栈
+
+### 核心技术
+- **TypeScript**: 提供类型安全和现代化开发体验
+- **Puppeteer**: 基于 Chrome DevTools Protocol 的浏览器自动化库
+- **rebrowser-puppeteer-core**: 增强的 Puppeteer 核心，提供更好的反检测能力
+- **puppeteer-extra**: Puppeteer 增强插件系统
+- **@octopus/bpmn**: 业务流程建模与执行引擎
+
+### 解析与处理
+- **xml2js/fast-xml-parser**: XML 文档解析与转换
+- **xpath/xmldom**: XPath 查询和 XML DOM 操作
+- **jsonpath**: JSON 路径查询
+- **sax**: 流式 XML 解析器
+
+### 网络与代理
+- **axios**: HTTP 请求客户端
+- **puppeteer-proxy**: 代理支持
+- **iconv-lite**: 字符编码转换
+
+### 工具库
+- **lodash-es**: 实用工具函数库
+- **moment**: 日期时间处理
+- **uuid**: 唯一标识符生成
+- **system-architecture**: 系统架构检测
+
+## 架构设计
+
+### 核心架构模式
+
+#### 1. 策略模式 (Strategy Pattern)
+```typescript
+// 动作类型映射
+const ActionClass = {
+  [ActionType.Navigate]: NavigateAction,
+  [ActionType.Click]: ClickAction,
+  [ActionType.ExtractData]: ExtractDataAction,
+  [ActionType.Loop]: LoopAction,
+  // ... 更多动作类型
+}
+```
+
+#### 2. 模板方法模式 (Template Method)
+所有动作都继承自 `BaseAction`，提供统一的执行流程：
+- `enter()` - 进入动作
+- `start()` - 开始执行  
+- `wait()` - 等待条件
+- `end()` - 结束处理
+- `leave()` - 离开清理
+
+#### 3. 观察者模式 (Observer Pattern)
+通过 `AsyncEmitter` 实现事件驱动的异步通信：
+```typescript
+class WorkflowAgent extends EventEmitter {
+  // 工作流状态事件
+  WorkflowEvents = {
+    Log: 'log',
+    ExtraData: 'extra-data', 
+    PauseTask: 'pause-task',
+    StopTask: 'stop-task',
+    // ...
+  }
+}
+```
+
+#### 4. 工厂模式 (Factory Pattern)
+`ActionFactory` 负责根据任务配置创建相应的动作实例。
+
+## 核心组件
+
+### 1. WorkflowAgent (工作流代理)
+- **职责**: 管理整个工作流的生命周期
+- **功能**: 
+  - 浏览器实例管理
+  - 任务执行控制 (启动/暂停/停止)
+  - 事件监听与分发
+  - 验证码处理
+  - 代理IP管理
+
+### 2. BaseAction (基础动作类)
+- **职责**: 所有动作的基类，定义通用行为
+- **核心功能**:
+  - 页面操作基础能力
+  - 重试机制
+  - 日志记录
+  - 代理IP切换
+  - 验证码处理
+  - 循环数据管理
+
+### 3. 具体动作实现
+
+#### NavigateAction (页面导航)
+- 页面跳转与加载
+- Cookie 管理
+- 缓存清理
+- 重试条件检查
+
+#### ClickAction (点击操作)
+- 元素定位与点击
+- 新窗口处理
+- 链接有效性验证
+- 点击重试机制
+
+#### ExtractDataAction (数据提取)
+- 多类型数据提取 (文本/HTML/链接/图片等)
+- XPath/CSS选择器支持
+- 数据清洗与格式化
+- 触发器机制
+
+#### LoopAction/LoopStartAction (循环处理)
+- 固定列表循环
+- 变量列表循环
+- URL列表循环
+- 滚动加载循环
+- 循环状态管理
+
+#### EnterTextAction (文本输入)
+- 表单填写
+- 输入验证
+- 清空与覆盖模式
+
+#### EnterCaptchaAction (验证码处理)
+- 图片验证码识别
+- 滑块验证码处理
+- reCAPTCHA 处理
+- hCaptcha 处理
+- 自定义验证码策略
+
+#### ConditionAction & BranchAction (条件分支)
+- 条件判断逻辑
+- 分支流程控制
+- 动态路径选择
+
+### 4. Browser Management (浏览器管理)
+- 自动下载与安装 Chrome
+- 跨平台支持 (Windows/macOS/Linux)
+- ARM64 架构适配
+- 浏览器实例池管理
+
+### 5. 工具模块
+
+#### AsyncEmitter (异步事件发射器)
+- 支持异步事件监听
+- Promise 化的事件处理
+
+#### DataStore (数据存储)
+- 循环数据缓存
+- 提取结果存储
+- 状态持久化
+
+#### HttpRequester (HTTP 请求器)
+- 网络请求封装
+- 代理支持
+- 重试机制
+
+#### JsonParser (JSON 解析器)
+- 复杂 JSON 数据解析
+- JSONPath 查询支持
+
+## 实现策略
+
+### 1. 反检测策略
+- 使用 `rebrowser-puppeteer-core` 提供更好的反检测能力
+- 禁用自动化标识: `--disable-blink-features=AutomationControlled`
+- 动态 User-Agent 切换
+- 代理IP轮换机制
+
+### 2. 稳定性策略
+- **重试机制**: 支持多种重试条件 (URL包含、文本包含、元素存在等)
+- **超时控制**: 每个步骤设置最大执行时间 (默认3分钟)
+- **异常恢复**: 页面崩溃自动恢复
+- **资源清理**: 及时释放浏览器资源
+
+### 3. 性能优化策略
+- **并发控制**: 支持多浏览器上下文并行执行
+- **资源管理**: 可选择禁用图片/广告加载
+- **内存优化**: 定期清理DOM缓存
+- **网络优化**: 请求拦截与代理
+
+### 4. 数据处理策略
+- **多格式支持**: 文本、HTML、JSON、图片、文件等
+- **数据清洗**: 自动去除HTML标签、空白字符
+- **编码处理**: 支持多种字符编码转换
+- **重复检测**: 防止数据重复采集
+
+### 5. 循环采集策略
+- **智能翻页**: 自动检测翻页按钮和加载更多
+- **滚动加载**: 支持无限滚动页面
+- **去重机制**: 基于XPath和内容的重复检测
+- **异常跳过**: 无效页面自动跳过机制
+
+## 主要功能特性
+
+### 🌐 页面操作
+- ✅ 页面导航与跳转
+- ✅ 多标签页/窗口管理
+- ✅ Cookie 和缓存管理
+- ✅ JavaScript 执行
+- ✅ 页面滚动和截图
+
+### 🎯 元素交互
+- ✅ 智能元素定位 (XPath/CSS选择器)
+- ✅ 点击、输入、鼠标悬停
+- ✅ 下拉框选择
+- ✅ 文件上传处理
+
+### 📊 数据提取
+- ✅ 文本内容提取
+- ✅ HTML源码获取
+- ✅ 链接和图片地址提取
+- ✅ 表格数据结构化提取
+- ✅ JSON API数据解析
+- ✅ OCR文字识别
+- ✅ 自定义字段生成
+
+### 🔄 流程控制
+- ✅ 条件判断与分支
+- ✅ 循环遍历 (固定/动态列表)
+- ✅ 异常处理与重试
+- ✅ 任务暂停/恢复/停止
+
+### 🛡️ 反检测与防护
+- ✅ User-Agent 伪装
+- ✅ 代理IP轮换
+- ✅ 请求频率控制
+- ✅ 浏览器指纹隐藏
+- ✅ 验证码智能处理
+
+### 🔧 高级功能
+- ✅ 自定义JavaScript执行
+- ✅ HTTP请求拦截与修改
+- ✅ 文件下载管理
+- ✅ 数据导出 (JSON/CSV/Excel)
+- ✅ 实时监控与日志
+
+## 使用示例
+
+### 基本工作流执行
+```typescript
+import { WorkflowAgent } from '@octopus/engine'
+
+const agent = new WorkflowAgent({
+  taskId: 'task-001',
+  xml: '原始任务XML',
+  xoml: '转换后的BPMN格式',
+  fieldNames: ['title', 'content', 'url'],
+  workflowSetting: new WorkflowSetting(),
+  userAgent: 'Mozilla/5.0...',
+  brokerSettings: new BrokerSettings()
+})
+
+// 启动工作流
+await agent.start({ 
+  headless: false,
+  path: '/path/to/chrome'
+})
+
+// 监听数据提取事件
+agent.on('extra-data', (data) => {
+  console.log('提取到数据:', data)
+})
+
+// 控制工作流
+agent.pause()  // 暂停
+agent.resume() // 恢复
+agent.stop()   // 停止
+```
+
+### 自定义动作扩展
+```typescript
+import BaseAction from './actions/BaseAction'
+
+class CustomAction extends BaseAction {
+  async start() {
+    // 自定义业务逻辑
+    const page = await this.getCurrentPage()
+    const result = await page.evaluate(() => {
+      // 页面内执行的代码
+      return document.title
+    })
+    
+    this.log('CustomAction', result)
+    return result
+  }
+}
+```
+
+## 配置选项
+
+### WorkflowSetting (工作流设置)
+```typescript
+{
+  showJumpInvalidClickSetting: true,    // 显示跳过无效点击选项
+  repeatPageLoopCount: 50,              // 重复页面循环判断次数
+  continuousJudgeCount: 5,              // 连续判断无效次数
+  actionWrapper: (action) => action     // 动作包装器
+}
+```
+
+### BrokerSettings (防封设置)
+```typescript
+{
+  ipProxySettings: {
+    ipProxyFromType: IpProxyFromType.None,
+    strongIpProxySettings: { period: 0 },
+    customIpProxySettings: { 
+      switchPeriod: 0, 
+      proxies: [] 
+    }
+  },
+  userAgentSwitchSettings: {
+    switchType: UserAgentSwitchType.None,
+    customPeriod: 0,
+    userAgents: []
+  },
+  cookieClearSettings: {
+    clearType: CookieClearType.None,
+    customPeriod: 0
+  }
+}
+```
+
+## 开发指南
+
+### 项目结构
+```
+src/
+├── actions/           # 动作实现
+├── configs/           # 配置定义
+├── enums/            # 枚举常量
+├── models/           # 数据模型
+├── translator/       # 任务转换器
+├── types/            # 类型定义
+├── utils/            # 工具函数
+├── browser.ts        # 浏览器管理
+├── browserProxy.ts   # 浏览器代理
+├── index.ts          # 主入口
+└── settings.ts       # 设置定义
+```
+
+### 构建与测试
+```bash
+# 安装依赖
+pnpm install
+
+# 类型检查
+pnpm lint
+
+# 构建项目
+pnpm build
+```
+
+## 许可证
+
+MIT License
+
+## 贡献指南
+
+欢迎提交 Issue 和 Pull Request 来改进这个项目。在贡献代码前，请确保：
+
+1. 遵循现有的代码风格
+2. 添加适当的类型定义
+3. 编写必要的测试用例
+4. 更新相关文档

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

@@ -0,0 +1,4 @@
+import BaseAction from './BaseAction';
+export default class BackPreWebPageAction extends BaseAction {
+    wait(): Promise<void>;
+}

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

@@ -0,0 +1 @@
+'use strict';var __importDefault=this&&this['__importDefault']||function(_0x27d8fe){return _0x27d8fe&&_0x27d8fe['__esModule']?_0x27d8fe:{'default':_0x27d8fe};};Object['defineProperty'](exports,'__esModule',{'value':!![]});const enums_1=require('../enums'),BaseAction_1=__importDefault(require('./BaseAction'));class BackPreWebPageAction extends BaseAction_1['default']{async['wait'](){if(this['getIsSkipCurrentLoop']()||this['getIsSkipActionUtilNextLoop'](this['getNodeId']())){this['finish']();return;}await super['wait'](),this['log'](enums_1['LogKey']['BackPreWebPage']['Begin'],this['name']);const _0x3fd7ca=await this['getCurrentPage']();try{await _0x3fd7ca['goBack']();}finally{this['finish']();}}}exports['default']=BackPreWebPageAction;