echoapi-cron-scheduler-batch 1.0.10 → 1.0.12

package/index.js

@@ -1,3 +1,18 @@
+const originalLog = console.log;
+console.log = function (...args) {
+  // 检查第一个参数是否包含 faker-js 或 node_modules 路径相关的字符串
+  const firstArg = String(args[0]);
+  if (
+    firstArg.includes('node_modules') &&
+    (firstArg.includes('@faker-js') || firstArg.includes('Module {'))
+  ) {
+    // 匹配到垃圾日志，直接丢弃，不执行打印
+    return;
+  }
+  // 正常的业务日志，调用原始方法打印
+  originalLog.apply(console, args);
+};
+// ==================================
 const cluster = require('cluster');
 const schedule = require('node-schedule');
 const _ = require('lodash');
@@ -5,144 +20,64 @@ const axios = require('axios');
 const path = require('path');
 const os = require('os');
 const JSON5 = require('json5');
-const Database = require('better-sqlite3');
 const fs = require('fs');
-const { v4: uuidv4 } = require('uuid');
-const { execSync } = require('child_process');
 
 /**
- * CronScheduler - 企业级多进程自动化测试调度器 (生产增强版)
+ * CronScheduler - 分布式原子文件调度器 (生产全功能版)
  */
 class CronScheduler {
   constructor(config = {}) {
-    // 1. 配置初始化
+    console.log('--------------------------------------------------');
+    console.log('🚀 [Init] CronScheduler 构造函数开始初始化...');
+
     this.apiUrl = config.apiUrl || process?.env["OPENAPI_DOMAIN"] || "https://ee.apipost.cc";
 
-    // 【优化】不要直接放 /tmp，在项目目录下创建持久化 data 目录
-    const dataDir = path.resolve(process?.env?.TEMP_DIR || os.tmpdir(), 'scheduler_data');
-    if (cluster.isPrimary && !fs.existsSync(dataDir)) {
-      fs.mkdirSync(dataDir, { recursive: true });
+    // 初始化路径：建议指向 NFS 挂载目录
+    const sharedRoot = config.sharedPath || path.resolve(process?.env?.TEMP_DIR || os.tmpdir(), 'shared_scheduler');
+    this.paths = {
+      jobs: path.join(sharedRoot, 'jobs'),
+      locks: path.join(sharedRoot, 'locks'),
+      results: path.join(sharedRoot, 'results'),
+    };
+
+    if (cluster.isPrimary) {
+      process.setMaxListeners(300);
+      this._initDirectories();
+      console.log(`🏠 [Master] 调度中心就绪 | 节点: ${os.hostname()} | 目录: ${sharedRoot}`);
     }
 
-    this.dbFile = config.dbPath || path.join(dataDir, 'echoapi-batch-tasks.sqlite');
     this.workerNum = config.workerNum || os.cpus().length;
-
-    // 结果聚合收集器 (仅在 Master 内存中存在)
     this.resultCollector = new Map();
-
-    // 2. 数据库连接与安全自检 (仅 Master 进程持有写连接)
-    if (cluster.isPrimary) {
-      this._connectDB();
-    }
   }
 
-  /**
-   * 内部方法：建立数据库连接并增加损坏自动修复逻辑
-   */
-  _connectDB() {
-    try {
-      // 预检：如果是 0 字节损坏文件，直接删除
-      if (fs.existsSync(this.dbFile) && fs.statSync(this.dbFile).size === 0) {
-        fs.unlinkSync(this.dbFile);
+  _initDirectories() {
+    Object.values(this.paths).forEach(dir => {
+      if (!fs.existsSync(dir)) {
+        fs.mkdirSync(dir, { recursive: true });
+        console.log(`📁 [System] 创建目录: ${dir}`);
       }
-
-      this.db = new Database(this.dbFile, { timeout: 10000 });
-
-      // 【核心】执行完整性自检，解决 malformed 和 not a database 问题
-      const check = this.db.pragma('integrity_check');
-      if (check[0].integrity_check !== 'ok') {
-        throw new Error('SQLite integrity check failed');
-      }
-
-      this._initDB();
-      console.log(`[Database] Connection verified and initialized.`);
-    } catch (e) {
-      console.error(`[Database Critical] 数据库损坏(Malformed/NotADb): ${e.message}`);
-      if (this.db) this.db.close();
-
-      // 自动备份损坏文件，腾出位置重建
-      const backupPath = `${this.dbFile}.corrupted_${Date.now()}`;
-      if (fs.existsSync(this.dbFile)) {
-        fs.renameSync(this.dbFile, backupPath);
-      }
-
-      // 重建数据库
-      this.db = new Database(this.dbFile);
-      this._initDB();
-      console.warn(`[Database] 坏库已隔离至 ${backupPath}，新库已就绪。`);
-    }
-  }
-
-  /**
-   * 初始化表结构与性能参数
-   */
-  _initDB() {
-    // 性能调优：WAL 模式能极大减少多进程读取时的锁竞争
-    this.db.pragma('journal_mode = WAL');
-    this.db.pragma('synchronous = NORMAL');
-    this.db.pragma('busy_timeout = 5000');
-
-    // 1. 任务配置表
-    this.db.prepare(`
-            CREATE TABLE IF NOT EXISTS jobs (
-                job_id TEXT PRIMARY KEY,
-                name TEXT,
-                frequency TEXT,
-                is_cancel INTEGER DEFAULT 0,
-                api_token TEXT,
-                project_id TEXT,
-                cases TEXT,
-                create_dtime INTEGER
-            )
-        `).run();
-
-    // 2. 中间结果暂存表 (Master 写入，聚合后删除)
-    this.db.prepare(`
-            CREATE TABLE IF NOT EXISTS task_results (
-                id INTEGER PRIMARY KEY AUTOINCREMENT,
-                execution_id TEXT,
-                data TEXT,
-                create_at INTEGER
-            )
-        `).run();
-    this.db.prepare(`CREATE INDEX IF NOT EXISTS idx_exec_id ON task_results(execution_id)`).run();
+    });
   }
 
+  // ==========================================
+  // 核心运行逻辑
+  // ==========================================
   run() {
     if (cluster.isPrimary) {
+      console.log(`👑 [Master] 主进程运行中 | PID: ${process.pid}`);
       this._startMaster();
     } else {
+      console.log(`👷 [Worker] 子进程运行中 | PID: ${process.pid}`);
       this._startWorker();
     }
   }
 
-  formatTimeToISO(time) {
-    if (!time) return null;
-    try {
-      const dayjs = require('dayjs');
-      const utc = require('dayjs/plugin/utc');
-      const timezone = require('dayjs/plugin/timezone');
-      dayjs.extend(utc);
-      dayjs.extend(timezone);
-      return dayjs(time).tz('Asia/Shanghai').format();
-    } catch (e) {
-      return new Date(time).toISOString();
-    }
-  }
-
-  // ==========================================
-  // Master 进程逻辑：单点读写
-  // ==========================================
-
   _startMaster() {
-    console.log(`[CronScheduler] Master ${process.pid} is running.`);
-
-    for (let i = 0; i < this.workerNum; i++) {
-      this._bindWorker(cluster.fork());
-    }
+    console.log(`🎋 [Master] 正在分配 ${this.workerNum} 个工作进程...`);
+    for (let i = 0; i < this.workerNum; i++) this._bindWorker(cluster.fork());
 
-    cluster.on('exit', (worker, code) => {
-      console.warn(`[CronScheduler] Worker ${worker.process.pid} died (code:${code}). Forking...`);
+    cluster.on('exit', (worker) => {
+      console.error(`🚨 [Master] Worker ${worker.process.pid} 离线，正在重启...`);
       this._bindWorker(cluster.fork());
     });
 
@@ -152,313 +87,357 @@ class CronScheduler {
   _bindWorker(worker) {
     worker.on('message', async (msg) => {
       if (msg.action === 'UNIT_COMPLETED') {
-        const { executionId, data } = msg.payload;
-        const record = this.resultCollector.get(executionId);
+        const { executionId, data, unitIndex } = msg.payload;
+        console.log(`📩 [Master] 收到执行反馈: ${executionId} [#${unitIndex}]`);
+
+        const resPath = path.join(this.paths.results, `${executionId}_${unitIndex}.res`);
+        fs.writeFileSync(resPath, JSON.stringify(data));
 
+        const record = this.resultCollector.get(executionId);
         if (record) {
-          try {
-            // 【单进程写入】只有 Master 负责操作数据库，规避并发写导致的损坏
-            this.db.prepare(`INSERT INTO task_results (execution_id, data, create_at) VALUES (?, ?, ?)`)
-              .run(executionId, JSON.stringify(data), Date.now());
-
-            // 计数检查
-            if (typeof record.received_count !== 'number') record.received_count = 0;
-            record.received_count++;
-
-            console.log(`[Progress] ${executionId}: ${record.received_count}/${record.total}`);
-
-            if (record.received_count >= record.total) {
-              await this._reportFromDB(executionId, record);
-            }
-          } catch (e) {
-            console.error(`[Master DB Write Error]`, e.message);
+          record.received_count++;
+          if (record.received_count >= record.total) {
+            console.log(`📦 [Master] 实例 ${executionId} 单元全部集齐，准备上报...`);
+            await this._aggregateAndReport(executionId, record);
           }
         }
       }
     });
   }
 
-  async _reportFromDB(executionId, record) {
+  // ==========================================
+  // 分布式锁与分发控制
+  // ==========================================
+  _tryAcquireLock(jobId) {
+    const lockFile = path.join(this.paths.locks, `${jobId}.lock`);
     try {
-      console.log(`[CronScheduler] Aggregating results for: ${executionId}`);
-      const rows = this.db.prepare(`SELECT data FROM task_results WHERE execution_id = ?`).all(executionId);
-
-      let stats = {
-        http_total: 0, http_success: 0,
-        assert_total: 0, assert_success: 0,
-        total_resp_time: 0
-      };
-
-      const results = rows.map(row => {
-        const item = JSON.parse(row.data);
-        stats.http_total += (item.http?.total || 0);
-        stats.http_success += (item.http?.success || 0);
-        stats.assert_total += (item.assert?.total || 0);
-        stats.assert_success += (item.assert?.success || 0);
-        stats.total_resp_time += (item.total_response_time || 0);
-
-        return _.assign(item, {
-          source: 'scheduled',
-          start_at: this.formatTimeToISO(item?.start_at),
-          end_at: this.formatTimeToISO(item?.end_at)
-        });
-      });
-
-      const httpRate = stats.http_total > 0 ? ((stats.http_success / stats.http_total) * 100).toFixed(2) : "0.00";
-      const assertRate = stats.assert_total > 0 ? ((stats.assert_success / stats.assert_total) * 100).toFixed(2) : "0.00";
-      const avgResp = results.length > 0 ? (stats.total_resp_time / results.length).toFixed(0) : 0;
-
-      const finalPayload = {
-        info: {
-          job_id: record.job_info.job_id,
-          report_name: record.job_info.name,
-          project_id: record.job_info.project_id,
-          execution_id: executionId,
-          start_at: this.formatTimeToISO(record.job_info.start_time),
-          end_at: this.formatTimeToISO(Date.now()),
-          http_pass_rate: `${httpRate}%`,
-          assert_pass_rate: `${assertRate}%`,
-          avg_response_time: `${avgResp}ms`,
-          total_http: stats.http_total,
-          success_http: stats.http_success,
-          total_assert: stats.assert_total,
-          success_assert: stats.assert_success,
-          total_units: record.total,
-          actual_units: results.length
-        },
-        results: results
-      };
-
-      const response = await axios.post(`${this.apiUrl}/open/hnzycfc/scheduled_task/report/add`, finalPayload, {
-        headers: { 'Content-Type': 'application/json', 'api-token': record.api_token },
-        maxContentLength: Infinity,
-        maxBodyLength: Infinity,
-        timeout: 60000 // 聚合报告可能很大，增加超时时间
-      });
-
-      if (response?.data?.code == 0) {
-        console.log(`[CronScheduler] Execution ${executionId} Success.`);
-        // 上报成功后清理中间数据
-        this.db.prepare(`DELETE FROM task_results WHERE execution_id = ?`).run(executionId);
-      } else {
-        console.error(`[Report Error] ${executionId}: ${response?.data?.msg}`);
-      }
-    } catch (err) {
-      console.error(`[Aggregation Error]`, err.stack);
-    } finally {
-      this.resultCollector.delete(executionId);
+      fs.writeFileSync(lockFile, JSON.stringify({ node: os.hostname(), time: Date.now() }), { flag: 'wx' });
+      console.log(`🔐 [Lock] 抢锁成功: ${jobId}`);
+      return true;
+    } catch (e) {
+      try {
+        const stats = fs.statSync(lockFile);
+        if (Date.now() - stats.mtimeMs > 1800000) { // 30分钟死锁保护
+          fs.unlinkSync(lockFile);
+          console.warn(`🔓 [Lock] 强制清理僵尸锁: ${jobId}`);
+        }
+      } catch (err) { }
+      return false;
     }
   }
 
+  _releaseLock(jobId) {
+    const lockFile = path.join(this.paths.locks, `${jobId}.lock`);
+    try { if (fs.existsSync(lockFile)) fs.unlinkSync(lockFile); } catch (e) { }
+  }
+
   _dispatch(job) {
-    try {
-      const runners = JSON5.parse(job.cases || '[]');
-      if (runners.length === 0) return;
+    console.log(`🎯 [Master] 准备分发: ${job.job_id} (${job.name || 'Task'})`);
+    if (!this._tryAcquireLock(job.job_id)) {
+      console.warn(`🔒 [Lock] 抢锁失败，跳过执行: ${job.job_id}`);
+      return;
+    }
 
+    try {
+      const runners = (typeof job.runners === 'string') ? JSON5.parse(job.runners || '[]') : (job.runners || []);
       const executionId = `${job.job_id}_${Date.now()}`;
-      this.resultCollector.set(executionId, {
-        total: runners.length,
-        received_count: 0,
-        api_token: job.api_token,
-        job_info: {
-          job_id: job.job_id,
-          name: job.name,
-          project_id: job.project_id,
-          start_time: Date.now()
-        }
-      });
+      this.resultCollector.set(executionId, { total: runners.length, received_count: 0, job_info: job });
 
-      const activeWorkers = Object.values(cluster.workers).filter(w => w.isConnected());
+      const workers = Object.values(cluster.workers).filter(w => w.isConnected());
       runners.forEach((runner, index) => {
-        const worker = _.sample(activeWorkers);
+        const worker = _.sample(workers);
         if (worker) {
           worker.send({
             action: 'EXECUTE_UNIT',
-            payload: { executionId, api_token: job.api_token, test_events: runner.test_events, option: runner.option, unit_index: index }
+            payload: { executionId, test_events: runner.test_events, option: runner.option, unitIndex: index, api_token: job.api_token }
           });
         }
       });
-    } catch (e) { console.error(`[Dispatch Error]:`, e.message); }
+      console.log(`📤 [Master] 已向 Worker 发送 ${runners.length} 个任务单元`);
+    } catch (e) {
+      console.error(`💥 [Master] 分发崩溃:`, e.message);
+      this._releaseLock(job.job_id);
+    }
   }
 
   // ==========================================
-  // Worker 进程逻辑：仅负责计算，不碰数据库
+  // 业务接口 (CRUD)
   // ==========================================
+  createJob(payload) {
+    console.log(`📝 [API] 创建/更新任务: ${payload.job_id}`);
+    const jobPath = path.join(this.paths.jobs, `${payload.job_id}.json`);
+    const cleanPayload = _.cloneDeep(payload);
 
-  _startWorker() {
-    console.log(`[Worker ${process.pid}] Ready.`);
-    const { run: runner } = require('runner-runtime');
-    const net = require('net');
-
-    process.on('message', async (msg) => {
-      if (msg.action === 'EXECUTE_UNIT') {
-        const { executionId, api_token, test_events, option } = msg.payload;
-        const socketPath = path.join(os.tmpdir(), `ea_${uuidv4().slice(0, 8)}.sock`);
-
-        const server = net.createServer((socket) => {
-          socket.on('data', async (stream) => {
-            try {
-              const info = JSON.parse(stream.toString());
-              await this._handleUnitScript(socket, info.action, info.data);
-            } catch (e) {
-              if (!socket.destroyed) socket.write(JSON.stringify({ status: 'error', message: e.message }) + "\n\n");
-            }
-          });
-        });
-
-        server.on('error', (err) => console.error(`[Socket Server Error] PID ${process.pid}: ${err.message}`));
-
-        server.listen(socketPath, () => {
-          const finalOptions = _.cloneDeep(option || {});
-          const base64Pipe = Buffer.from(socketPath).toString('base64');
-          _.set(finalOptions, 'env.ELECTRON_PIPE', base64Pipe);
-
-          runner(test_events, finalOptions, (res) => {
-            if (res?.action === 'complete') {
-              if (process.connected) {
-                process.send({ action: 'UNIT_COMPLETED', payload: { executionId, data: res.data, api_token } });
-              }
-              server.close();
-              try { if (fs.existsSync(socketPath)) fs.unlinkSync(socketPath); } catch (e) { }
-            }
-          });
-        });
-      }
-    });
+    if (typeof cleanPayload.frequency === 'string') {
+      try { cleanPayload.frequency = JSON5.parse(cleanPayload.frequency); } catch (e) { }
+    }
+    if (typeof cleanPayload.runners === 'string') {
+      try { cleanPayload.runners = JSON5.parse(cleanPayload.runners); } catch (e) { }
+    }
 
-    process.on('uncaughtException', (err) => {
-      console.error('[Worker Fatal] Exception:', err.message);
-    });
+    const jobData = { ...cleanPayload, is_cancel: 0, create_dtime: Date.now() };
+    fs.writeFileSync(jobPath, JSON.stringify(jobData, null, 2), 'utf8');
+    this.upsertTimer(jobData.job_id, jobData.frequency, jobData);
+    return true;
   }
 
-  // ==========================================
-  // 业务与辅助方法
-  // ==========================================
+  getAllJobs(project_id) {
+    console.log(`🔍 [API] 查询项目任务列表: ${project_id}`);
+    if (!fs.existsSync(this.paths.jobs)) return [];
+    return fs.readdirSync(this.paths.jobs).map(f => {
+      try {
+        const raw = fs.readFileSync(path.join(this.paths.jobs, f), 'utf8');
+        if (!raw) return null;
+        const job = JSON.parse(raw);
+        if (job.project_id !== project_id) return null;
+
+        const cron = this.convertToCron(job.frequency);
+        const runners = (typeof job.runners === 'string') ? JSON5.parse(job.runners || '[]') : (job.runners || []);
+
+        return {
+          ..._.omit(job, ['runners']),
+          status: job.is_cancel === 0 ? 0 : 1,
+          next_run_time: this.getNextExecutionTime(cron),
+          runners: _.map(runners, v => v?.option?.testing_id).filter(Boolean)
+        };
+      } catch (e) { return null; }
+    }).filter(Boolean);
+  }
 
-  async _handleUnitScript(socket, action, data) {
-    try {
-      switch (action) {
-        case 'queryDatabase': {
-          const { DatabaseQuery } = require('database-query');
-          const result = await DatabaseQuery(data.dbconfig, data.query);
-          socket.write(JSON.stringify(result) + "\n\n");
-          break;
-        }
-        case 'execute': {
-          const commandMap = { 'jar': 'java -jar', 'php': 'php -f', 'js': 'node', 'py': 'python3', 'py3': 'python3', 'go': 'go run', 'sh': 'sh' };
-          const ext = path.extname(data.file).slice(1).toLowerCase();
-          const command = `${commandMap[ext] || ''} ${data.file} ${(data.args || []).join(' ')}`;
-          const output = execSync(command, _.assign({ encoding: process.platform === 'win32' ? 'cp936' : 'utf8' }, data.option || {}));
-          socket.write(JSON.stringify({ status: 'success', result: String(output) }) + "\n\n");
-          break;
-        }
-      }
-    } catch (err) {
-      socket.write(JSON.stringify({ status: 'error', message: err.message }) + "\n\n");
-    }
+  deleteJob(job_id) {
+    console.log(`🗑️ [API] 删除任务: ${job_id}`);
+    const filePath = path.join(this.paths.jobs, `${job_id}.json`);
+    if (fs.existsSync(filePath)) fs.unlinkSync(filePath);
+    if (schedule.scheduledJobs[job_id]) schedule.scheduledJobs[job_id].cancel();
+    this._releaseLock(job_id);
+    return true;
   }
 
-  loadJobs() {
-    console.log('[CronScheduler] Loading timers from DB...');
-    Object.values(schedule.scheduledJobs).forEach(j => j.cancel());
-    try {
-      const jobs = this.db.prepare(`SELECT * FROM jobs WHERE is_cancel < 1`).all();
-      jobs.forEach(job => this.upsertTimer(job.job_id, job.name, job.frequency, job));
-    } catch (e) {
-      console.error('[Load Jobs Error]', e.message);
+  cancelJob(job_id) {
+    const filePath = path.join(this.paths.jobs, `${job_id}.json`);
+    if (fs.existsSync(filePath)) {
+      const job = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      job.is_cancel = 1;
+      fs.writeFileSync(filePath, JSON.stringify(job, null, 2), 'utf8');
     }
+    if (schedule.scheduledJobs[job_id]) schedule.scheduledJobs[job_id].cancel();
+    console.log(`⏸️ [API] 任务已暂停: ${job_id}`);
+    return true;
   }
 
-  upsertTimer(job_id, name, frequency, jobData) {
-    if (schedule.scheduledJobs[job_id]) schedule.scheduledJobs[job_id].cancel();
-    if (jobData?.is_cancel < 1) {
-      const cronRule = this.convertToCron(frequency);
-      schedule.scheduleJob(job_id, cronRule, () => {
-        const currentJob = this.db.prepare(`SELECT * FROM jobs WHERE job_id = ?`).get(job_id);
-        if (currentJob && currentJob.is_cancel < 1) this._dispatch(currentJob);
-      });
+  restartJob(job_id) {
+    const filePath = path.join(this.paths.jobs, `${job_id}.json`);
+    if (fs.existsSync(filePath)) {
+      const job = JSON.parse(fs.readFileSync(filePath, 'utf8'));
+      job.is_cancel = 0;
+      fs.writeFileSync(filePath, JSON.stringify(job, null, 2), 'utf8');
+      this.upsertTimer(job_id, job.frequency, job);
+      console.log(`▶️ [API] 任务已重启: ${job_id}`);
+      return true;
     }
+    return false;
   }
 
-  createJob(payload) {
-    const { job_id, name, frequency, api_token, project_id, runners } = payload;
-    const stmt = this.db.prepare(`
-            INSERT INTO jobs (job_id, name, frequency, api_token, project_id, cases, create_dtime)
-            VALUES (?, ?, ?, ?, ?, ?, ?)
-            ON CONFLICT(job_id) DO UPDATE SET name=excluded.name, frequency=excluded.frequency, cases=excluded.cases, api_token=excluded.api_token, is_cancel=0
-        `);
-    stmt.run(job_id, name, JSON.stringify(frequency), api_token, project_id, JSON.stringify(runners || []), Date.now());
-    this.upsertTimer(job_id, name, frequency, { is_cancel: 0 });
-    return true;
+  loadJobs() {
+    if (!fs.existsSync(this.paths.jobs)) return;
+    const files = fs.readdirSync(this.paths.jobs);
+    console.log(`🔍 [Load] 正在加载本地任务，共 ${files.length} 个`);
+    files.forEach(f => {
+      try {
+        const job = JSON.parse(fs.readFileSync(path.join(this.paths.jobs, f), 'utf8'));
+        if (job.is_cancel < 1) this.upsertTimer(job.job_id, job.frequency, job);
+      } catch (e) { }
+    });
   }
 
-  cancelJob(job_id) {
-    this.db.prepare(`UPDATE jobs SET is_cancel = 1 WHERE job_id = ?`).run(job_id);
+  upsertTimer(job_id, frequency, jobData) {
     if (schedule.scheduledJobs[job_id]) schedule.scheduledJobs[job_id].cancel();
-    return true;
+    const cron = this.convertToCron(frequency);
+
+    const nodeJob = schedule.scheduleJob(job_id, cron, () => {
+      console.log(`🔔 [Timer] >>> 定时点激活: ${job_id}`);
+      const jobPath = path.join(this.paths.jobs, `${job_id}.json`);
+      if (!fs.existsSync(jobPath)) return;
+      const job = JSON.parse(fs.readFileSync(jobPath, 'utf8'));
+      if (job.is_cancel < 1) this._dispatch(job);
+    });
+
+    if (nodeJob) {
+      console.log(`✅ [Timer] 任务 ${job_id} 挂载成功，下次执行: ${nodeJob.nextInvocation()?.toLocaleString()}`);
+    }
   }
 
-  /**
-     * 重启已暂停的任务
-     */
-  restartJob(job_id) {
+  // ==========================================
+  // 上报与 Worker 执行
+  // ==========================================
+  async _aggregateAndReport(executionId, record) {
+    console.log(`📊 [Report] 任务 ${executionId} 集齐，准备上报...`);
     try {
-      // 1. 更新数据库状态
-      this.db.prepare(`UPDATE jobs SET is_cancel = 0 WHERE job_id = ?`).run(job_id);
-
-      // 2. 获取最新数据并重新注册定时器
-      const job = this.db.prepare(`SELECT * FROM jobs WHERE job_id = ?`).get(job_id);
-      if (job) {
-        this.upsertTimer(job.job_id, job.name, job.frequency, job);
-        console.log(`[CronScheduler] Job ${job_id} restarted.`);
-        return true;
+      // 读取文件系统中的分片结果
+      const files = fs.readdirSync(this.paths.results).filter(f => f.startsWith(executionId));
+      const rawResults = files.map(f => {
+        const p = path.join(this.paths.results, f);
+        const data = JSON.parse(fs.readFileSync(p, 'utf8'));
+        try { fs.unlinkSync(p); } catch (e) { } // 读完立即删除
+        return data;
+      });
+
+      // 调用上面的增强统计方法获取 Payload
+      const finalPayload = this._calculateStats(rawResults, record, executionId);
+      // fs.writeFileSync('finalPayload.json', JSON.stringify(finalPayload))
+      const response = await axios.post(`${this.apiUrl}/open/hnzycfc/scheduled_task/report/add`, finalPayload, {
+        headers: { 'api-token': record.job_info.api_token },
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity
+      });
+      if (response?.data?.code == 0) {
+        console.log(`✨ [Report] 上报成功! 任务ID: ${record.job_info.job_id} | 状态: ${response.status}`);
+      } else {
+        console.error(`❌ [Report] code 上报失败 ${executionId}: ${response?.data?.msg}`);
       }
-      return false;
+
     } catch (e) {
-      console.error(`[Restart Job Error] ${job_id}:`, e.message);
-      return false;
+      console.error(`❌ [Report] 上报失败: ${executionId}`, e.message);
+    } finally {
+      this._releaseLock(record.job_info.job_id);
+      this.resultCollector.delete(executionId);
     }
   }
 
-  deleteJob(job_id) {
-    this.db.prepare(`DELETE FROM jobs WHERE job_id = ?`).run(job_id);
-    if (schedule.scheduledJobs[job_id]) schedule.scheduledJobs[job_id].cancel();
-    return true;
+  _startWorker() {
+    const { run: runner } = require('runner-runtime');
+    process.on('message', async (msg) => {
+      if (msg.action === 'EXECUTE_UNIT') {
+        console.log(`⚙️ [Worker ${process.pid}] 执行单元: ${msg.payload.executionId}`);
+        runner(msg.payload.test_events, msg.payload.option || {}, (res) => {
+          if (res?.action === 'complete') {
+            process.send({ action: 'UNIT_COMPLETED', payload: { ...msg.payload, data: res.data } });
+          }
+        });
+      }
+    });
   }
 
-  getAllJobs(project_id) {
-    const jobs = this.db.prepare(`SELECT * FROM jobs WHERE project_id = ?`).all(project_id);
-    return jobs.map(job => ({
-      ..._.omit(job, ['cases']),
-      status: job.is_cancel === 0 ? 0 : 1,
-      next_run_time: this.getNextExecutionTime(this.convertToCron(job.frequency)),
-      runners: JSON5.parse(job.cases || '[]').map(v => v?.option?.testing_id)
-    }));
+  // ==========================================
+  // 工具类
+  // ==========================================
+  _calculateStats(results, record, executionId) {
+    let s = {
+      http_total: 0, http_success: 0,
+      assert_total: 0, assert_success: 0,
+      total_resp_time: 0
+    };
+
+    // 1. 遍历并处理每个结果单元
+    const processedResults = results.map(item => {
+      // 累加统计
+      s.http_total += (item.http?.total || 0);
+      s.http_success += (item.http?.success || 0);
+      s.assert_total += (item.assert?.total || 0);
+      s.assert_success += (item.assert?.success || 0);
+      s.total_resp_time += (item.total_response_time || 0);
+
+      // 还原 item 内部字段
+      return _.assign(item, {
+        source: 'scheduled',
+        start_at: this.formatTimeToISO(item?.start_at || Date.now()),
+        end_at: this.formatTimeToISO(item?.end_at || Date.now())
+      });
+    });
+
+    // 2. 计算通过率等指标
+    const httpRate = s.http_total > 0 ? ((s.http_success / s.http_total) * 100).toFixed(2) : "0.00";
+    const assertRate = s.assert_total > 0 ? ((s.assert_success / s.assert_total) * 100).toFixed(2) : "0.00";
+    const avgResp = processedResults.length > 0 ? (s.total_resp_time / processedResults.length).toFixed(0) : 0;
+
+    // 3. 封装与之前 DB 版本完全一致的 Payload
+    return {
+      info: {
+        job_id: record.job_info.job_id,
+        report_name: record.job_info.name,
+        project_id: record.job_info.project_id,
+        execution_id: executionId,
+        // 使用任务开始时间和当前结束时间
+
+        start_at: this.formatTimeToISO(record.job_info.start_time || Date.now()),
+        end_at: this.formatTimeToISO(Date.now()),
+        http_pass_rate: `${httpRate}%`,
+        assert_pass_rate: `${assertRate}%`,
+        avg_response_time: `${avgResp}ms`,
+        total_http: s.http_total,
+        success_http: s.http_success,
+        total_assert: s.assert_total,
+        success_assert: s.assert_success,
+        total_units: record.total,
+        actual_units: processedResults.length
+      },
+      results: processedResults
+    };
+  }
+
+  getNextExecutionTime(cron) {
+    const { CronExpressionParser } = require('cron-parser');
+    const interval = CronExpressionParser.parse(cron, { tz: 'Asia/Shanghai', utc: false });
+    return new Date(interval.next().toISOString()).getTime()
   }
 
   convertToCron(freq) {
+    if (!freq) return '0 0 0 * * *';
     const data = typeof freq === 'string' ? JSON5.parse(freq) : freq;
+
+    // 情况 A：用户直接传 Cron 表达式
     if (data.type === 'cron') {
       const exp = data.cron?.expression || '0 0 * * *';
       const parts = exp.trim().split(/\s+/);
+      // 如果是 5 位，补齐第 0 位为 0 秒，确保不重复触发
       return parts.length === 5 ? `0 ${exp}` : exp;
     }
+
+    // 情况 B：预设周期配置
     if (data.type === 'preset') {
       const { cycle, config } = data.preset;
-      const [h, m] = (config.time || "0:0").split(':');
-      if (cycle === 'minute') return `0 */${config.interval} * * * *`;
-      if (cycle === 'hour') return `0 0 */${config.interval} * * *`;
-      if (cycle === 'day') return `0 ${parseInt(m)} ${parseInt(h)} * * *`;
-      if (cycle === 'week') return `0 ${parseInt(m)} ${parseInt(h)} * * ${Array.isArray(config.weekdays) ? config.weekdays.join(',') : '*'}`;
+
+      switch (cycle) {
+        case 'minute':
+          // 修正：强制 0 秒开始，每 interval 分钟执行
+          return `0 */${config.interval} * * * *`;
+
+        case 'hour':
+          // 修正：强制 0 秒 0 分开始，每 interval 小时执行
+          return `0 0 */${config.interval} * * *`;
+
+        case 'day': {
+          // 兼容 '10:30' 这种格式
+          const [hour, minute] = (config.time || "0:0").split(':');
+          return `0 ${parseInt(minute)} ${parseInt(hour)} * * *`;
+        }
+
+        case 'week': {
+          const [hour, minute] = (config.time || "0:0").split(':');
+          // config.weekdays 应该是 [1, 3, 5] 这种数组
+          const days = Array.isArray(config.weekdays) ? config.weekdays.join(',') : '*';
+          return `0 ${parseInt(minute)} ${parseInt(hour)} * * ${days}`;
+        }
+
+        default:
+          return '0 0 0 * * *';
+      }
     }
+
     return '0 0 0 * * *';
   }
 
-  getNextExecutionTime(cron) {
-    try {
-      const { CronExpressionParser } = require('cron-parser');
-      return CronExpressionParser.parse(cron, { tz: 'Asia/Shanghai' }).next().getTime();
-    } catch (e) { return '-'; }
+
+  /**
+ * Converts timestamp to ISO format
+ */
+  formatTimeToISO(time) {
+    const dayjs = require('dayjs');
+    const utc = require('dayjs/plugin/utc');
+    const timezone = require('dayjs/plugin/timezone');
+    dayjs.extend(utc);
+    dayjs.extend(timezone);
+    return dayjs(time).tz('Asia/Shanghai').format();
   }
 }
 

package/index_bak1.js

@@ -0,0 +1,465 @@
+const cluster = require('cluster');
+const schedule = require('node-schedule');
+const _ = require('lodash');
+const axios = require('axios');
+const path = require('path');
+const os = require('os');
+const JSON5 = require('json5');
+const Database = require('better-sqlite3');
+const fs = require('fs');
+const { v4: uuidv4 } = require('uuid');
+const { execSync } = require('child_process');
+
+/**
+ * CronScheduler - 企业级多进程自动化测试调度器 (生产增强版)
+ */
+class CronScheduler {
+  constructor(config = {}) {
+    // 1. 配置初始化
+    this.apiUrl = config.apiUrl || process?.env["OPENAPI_DOMAIN"] || "https://ee.apipost.cc";
+
+    // 【优化】不要直接放 /tmp，在项目目录下创建持久化 data 目录
+    const dataDir = path.resolve(process?.env?.TEMP_DIR || os.tmpdir(), 'scheduler_data');
+    if (cluster.isPrimary && !fs.existsSync(dataDir)) {
+      fs.mkdirSync(dataDir, { recursive: true });
+    }
+
+    this.dbFile = config.dbPath || path.join(dataDir, 'echoapi-batch-tasks.sqlite');
+    this.workerNum = config.workerNum || os.cpus().length;
+
+    // 结果聚合收集器 (仅在 Master 内存中存在)
+    this.resultCollector = new Map();
+
+    // 2. 数据库连接与安全自检 (仅 Master 进程持有写连接)
+    if (cluster.isPrimary) {
+      this._connectDB();
+    }
+  }
+
+  /**
+   * 内部方法：建立数据库连接并增加损坏自动修复逻辑
+   */
+  _connectDB() {
+    try {
+      // 预检：如果是 0 字节损坏文件，直接删除
+      if (fs.existsSync(this.dbFile) && fs.statSync(this.dbFile).size === 0) {
+        fs.unlinkSync(this.dbFile);
+      }
+
+      this.db = new Database(this.dbFile, { timeout: 10000 });
+
+      // 【核心】执行完整性自检，解决 malformed 和 not a database 问题
+      const check = this.db.pragma('integrity_check');
+      if (check[0].integrity_check !== 'ok') {
+        throw new Error('SQLite integrity check failed');
+      }
+
+      this._initDB();
+      console.log(`[Database] Connection verified and initialized.`);
+    } catch (e) {
+      console.error(`[Database Critical] 数据库损坏(Malformed/NotADb): ${e.message}`);
+      if (this.db) this.db.close();
+
+      // 自动备份损坏文件，腾出位置重建
+      const backupPath = `${this.dbFile}.corrupted_${Date.now()}`;
+      if (fs.existsSync(this.dbFile)) {
+        fs.renameSync(this.dbFile, backupPath);
+      }
+
+      // 重建数据库
+      this.db = new Database(this.dbFile);
+      this._initDB();
+      console.warn(`[Database] 坏库已隔离至 ${backupPath}，新库已就绪。`);
+    }
+  }
+
+  /**
+   * 初始化表结构与性能参数
+   */
+  _initDB() {
+    // 性能调优：WAL 模式能极大减少多进程读取时的锁竞争
+    this.db.pragma('journal_mode = WAL');
+    this.db.pragma('synchronous = NORMAL');
+    this.db.pragma('busy_timeout = 5000');
+
+    // 1. 任务配置表
+    this.db.prepare(`
+            CREATE TABLE IF NOT EXISTS jobs (
+                job_id TEXT PRIMARY KEY,
+                name TEXT,
+                frequency TEXT,
+                is_cancel INTEGER DEFAULT 0,
+                api_token TEXT,
+                project_id TEXT,
+                cases TEXT,
+                create_dtime INTEGER
+            )
+        `).run();
+
+    // 2. 中间结果暂存表 (Master 写入，聚合后删除)
+    this.db.prepare(`
+            CREATE TABLE IF NOT EXISTS task_results (
+                id INTEGER PRIMARY KEY AUTOINCREMENT,
+                execution_id TEXT,
+                data TEXT,
+                create_at INTEGER
+            )
+        `).run();
+    this.db.prepare(`CREATE INDEX IF NOT EXISTS idx_exec_id ON task_results(execution_id)`).run();
+  }
+
+  run() {
+    if (cluster.isPrimary) {
+      this._startMaster();
+    } else {
+      this._startWorker();
+    }
+  }
+
+  formatTimeToISO(time) {
+    if (!time) return null;
+    try {
+      const dayjs = require('dayjs');
+      const utc = require('dayjs/plugin/utc');
+      const timezone = require('dayjs/plugin/timezone');
+      dayjs.extend(utc);
+      dayjs.extend(timezone);
+      return dayjs(time).tz('Asia/Shanghai').format();
+    } catch (e) {
+      return new Date(time).toISOString();
+    }
+  }
+
+  // ==========================================
+  // Master 进程逻辑：单点读写
+  // ==========================================
+
+  _startMaster() {
+    console.log(`[CronScheduler] Master ${process.pid} is running.`);
+
+    for (let i = 0; i < this.workerNum; i++) {
+      this._bindWorker(cluster.fork());
+    }
+
+    cluster.on('exit', (worker, code) => {
+      console.warn(`[CronScheduler] Worker ${worker.process.pid} died (code:${code}). Forking...`);
+      this._bindWorker(cluster.fork());
+    });
+
+    this.loadJobs();
+  }
+
+  _bindWorker(worker) {
+    worker.on('message', async (msg) => {
+      if (msg.action === 'UNIT_COMPLETED') {
+        const { executionId, data } = msg.payload;
+        const record = this.resultCollector.get(executionId);
+
+        if (record) {
+          try {
+            // 【单进程写入】只有 Master 负责操作数据库，规避并发写导致的损坏
+            this.db.prepare(`INSERT INTO task_results (execution_id, data, create_at) VALUES (?, ?, ?)`)
+              .run(executionId, JSON.stringify(data), Date.now());
+
+            // 计数检查
+            if (typeof record.received_count !== 'number') record.received_count = 0;
+            record.received_count++;
+
+            console.log(`[Progress] ${executionId}: ${record.received_count}/${record.total}`);
+
+            if (record.received_count >= record.total) {
+              await this._reportFromDB(executionId, record);
+            }
+          } catch (e) {
+            console.error(`[Master DB Write Error]`, e.message);
+          }
+        }
+      }
+    });
+  }
+
+  async _reportFromDB(executionId, record) {
+    try {
+      console.log(`[CronScheduler] Aggregating results for: ${executionId}`);
+      const rows = this.db.prepare(`SELECT data FROM task_results WHERE execution_id = ?`).all(executionId);
+
+      let stats = {
+        http_total: 0, http_success: 0,
+        assert_total: 0, assert_success: 0,
+        total_resp_time: 0
+      };
+
+      const results = rows.map(row => {
+        const item = JSON.parse(row.data);
+        stats.http_total += (item.http?.total || 0);
+        stats.http_success += (item.http?.success || 0);
+        stats.assert_total += (item.assert?.total || 0);
+        stats.assert_success += (item.assert?.success || 0);
+        stats.total_resp_time += (item.total_response_time || 0);
+
+        return _.assign(item, {
+          source: 'scheduled',
+          start_at: this.formatTimeToISO(item?.start_at),
+          end_at: this.formatTimeToISO(item?.end_at)
+        });
+      });
+
+      const httpRate = stats.http_total > 0 ? ((stats.http_success / stats.http_total) * 100).toFixed(2) : "0.00";
+      const assertRate = stats.assert_total > 0 ? ((stats.assert_success / stats.assert_total) * 100).toFixed(2) : "0.00";
+      const avgResp = results.length > 0 ? (stats.total_resp_time / results.length).toFixed(0) : 0;
+
+      const finalPayload = {
+        info: {
+          job_id: record.job_info.job_id,
+          report_name: record.job_info.name,
+          project_id: record.job_info.project_id,
+          execution_id: executionId,
+          start_at: this.formatTimeToISO(record.job_info.start_time),
+          end_at: this.formatTimeToISO(Date.now()),
+          http_pass_rate: `${httpRate}%`,
+          assert_pass_rate: `${assertRate}%`,
+          avg_response_time: `${avgResp}ms`,
+          total_http: stats.http_total,
+          success_http: stats.http_success,
+          total_assert: stats.assert_total,
+          success_assert: stats.assert_success,
+          total_units: record.total,
+          actual_units: results.length
+        },
+        results: results
+      };
+
+      const response = await axios.post(`${this.apiUrl}/open/hnzycfc/scheduled_task/report/add`, finalPayload, {
+        headers: { 'Content-Type': 'application/json', 'api-token': record.api_token },
+        maxContentLength: Infinity,
+        maxBodyLength: Infinity,
+        timeout: 60000 // 聚合报告可能很大，增加超时时间
+      });
+
+      if (response?.data?.code == 0) {
+        console.log(`[CronScheduler] Execution ${executionId} Success.`);
+        // 上报成功后清理中间数据
+        this.db.prepare(`DELETE FROM task_results WHERE execution_id = ?`).run(executionId);
+      } else {
+        console.error(`[Report Error] ${executionId}: ${response?.data?.msg}`);
+      }
+    } catch (err) {
+      console.error(`[Aggregation Error]`, err.stack);
+    } finally {
+      this.resultCollector.delete(executionId);
+    }
+  }
+
+  _dispatch(job) {
+    try {
+      const runners = JSON5.parse(job.cases || '[]');
+      if (runners.length === 0) return;
+
+      const executionId = `${job.job_id}_${Date.now()}`;
+      this.resultCollector.set(executionId, {
+        total: runners.length,
+        received_count: 0,
+        api_token: job.api_token,
+        job_info: {
+          job_id: job.job_id,
+          name: job.name,
+          project_id: job.project_id,
+          start_time: Date.now()
+        }
+      });
+
+      const activeWorkers = Object.values(cluster.workers).filter(w => w.isConnected());
+      runners.forEach((runner, index) => {
+        const worker = _.sample(activeWorkers);
+        if (worker) {
+          worker.send({
+            action: 'EXECUTE_UNIT',
+            payload: { executionId, api_token: job.api_token, test_events: runner.test_events, option: runner.option, unit_index: index }
+          });
+        }
+      });
+    } catch (e) { console.error(`[Dispatch Error]:`, e.message); }
+  }
+
+  // ==========================================
+  // Worker 进程逻辑：仅负责计算，不碰数据库
+  // ==========================================
+
+  _startWorker() {
+    console.log(`[Worker ${process.pid}] Ready.`);
+    const { run: runner } = require('runner-runtime');
+    const net = require('net');
+
+    process.on('message', async (msg) => {
+      if (msg.action === 'EXECUTE_UNIT') {
+        const { executionId, api_token, test_events, option } = msg.payload;
+        const socketPath = path.join(os.tmpdir(), `ea_${uuidv4().slice(0, 8)}.sock`);
+
+        const server = net.createServer((socket) => {
+          socket.on('data', async (stream) => {
+            try {
+              const info = JSON.parse(stream.toString());
+              await this._handleUnitScript(socket, info.action, info.data);
+            } catch (e) {
+              if (!socket.destroyed) socket.write(JSON.stringify({ status: 'error', message: e.message }) + "\n\n");
+            }
+          });
+        });
+
+        server.on('error', (err) => console.error(`[Socket Server Error] PID ${process.pid}: ${err.message}`));
+
+        server.listen(socketPath, () => {
+          const finalOptions = _.cloneDeep(option || {});
+          const base64Pipe = Buffer.from(socketPath).toString('base64');
+          _.set(finalOptions, 'env.ELECTRON_PIPE', base64Pipe);
+
+          runner(test_events, finalOptions, (res) => {
+            if (res?.action === 'complete') {
+              if (process.connected) {
+                process.send({ action: 'UNIT_COMPLETED', payload: { executionId, data: res.data, api_token } });
+              }
+              server.close();
+              try { if (fs.existsSync(socketPath)) fs.unlinkSync(socketPath); } catch (e) { }
+            }
+          });
+        });
+      }
+    });
+
+    process.on('uncaughtException', (err) => {
+      console.error('[Worker Fatal] Exception:', err.message);
+    });
+  }
+
+  // ==========================================
+  // 业务与辅助方法
+  // ==========================================
+
+  async _handleUnitScript(socket, action, data) {
+    try {
+      switch (action) {
+        case 'queryDatabase': {
+          const { DatabaseQuery } = require('database-query');
+          const result = await DatabaseQuery(data.dbconfig, data.query);
+          socket.write(JSON.stringify(result) + "\n\n");
+          break;
+        }
+        case 'execute': {
+          const commandMap = { 'jar': 'java -jar', 'php': 'php -f', 'js': 'node', 'py': 'python3', 'py3': 'python3', 'go': 'go run', 'sh': 'sh' };
+          const ext = path.extname(data.file).slice(1).toLowerCase();
+          const command = `${commandMap[ext] || ''} ${data.file} ${(data.args || []).join(' ')}`;
+          const output = execSync(command, _.assign({ encoding: process.platform === 'win32' ? 'cp936' : 'utf8' }, data.option || {}));
+          socket.write(JSON.stringify({ status: 'success', result: String(output) }) + "\n\n");
+          break;
+        }
+      }
+    } catch (err) {
+      socket.write(JSON.stringify({ status: 'error', message: err.message }) + "\n\n");
+    }
+  }
+
+  loadJobs() {
+    console.log('[CronScheduler] Loading timers from DB...');
+    Object.values(schedule.scheduledJobs).forEach(j => j.cancel());
+    try {
+      const jobs = this.db.prepare(`SELECT * FROM jobs WHERE is_cancel < 1`).all();
+      jobs.forEach(job => this.upsertTimer(job.job_id, job.name, job.frequency, job));
+    } catch (e) {
+      console.error('[Load Jobs Error]', e.message);
+    }
+  }
+
+  upsertTimer(job_id, name, frequency, jobData) {
+    if (schedule.scheduledJobs[job_id]) schedule.scheduledJobs[job_id].cancel();
+    if (jobData?.is_cancel < 1) {
+      const cronRule = this.convertToCron(frequency);
+      schedule.scheduleJob(job_id, cronRule, () => {
+        const currentJob = this.db.prepare(`SELECT * FROM jobs WHERE job_id = ?`).get(job_id);
+        if (currentJob && currentJob.is_cancel < 1) this._dispatch(currentJob);
+      });
+    }
+  }
+
+  createJob(payload) {
+    const { job_id, name, frequency, api_token, project_id, runners } = payload;
+    const stmt = this.db.prepare(`
+            INSERT INTO jobs (job_id, name, frequency, api_token, project_id, cases, create_dtime)
+            VALUES (?, ?, ?, ?, ?, ?, ?)
+            ON CONFLICT(job_id) DO UPDATE SET name=excluded.name, frequency=excluded.frequency, cases=excluded.cases, api_token=excluded.api_token, is_cancel=0
+        `);
+    stmt.run(job_id, name, JSON.stringify(frequency), api_token, project_id, JSON.stringify(runners || []), Date.now());
+    this.upsertTimer(job_id, name, frequency, { is_cancel: 0 });
+    return true;
+  }
+
+  cancelJob(job_id) {
+    this.db.prepare(`UPDATE jobs SET is_cancel = 1 WHERE job_id = ?`).run(job_id);
+    if (schedule.scheduledJobs[job_id]) schedule.scheduledJobs[job_id].cancel();
+    return true;
+  }
+
+  /**
+     * 重启已暂停的任务
+     */
+  restartJob(job_id) {
+    try {
+      // 1. 更新数据库状态
+      this.db.prepare(`UPDATE jobs SET is_cancel = 0 WHERE job_id = ?`).run(job_id);
+
+      // 2. 获取最新数据并重新注册定时器
+      const job = this.db.prepare(`SELECT * FROM jobs WHERE job_id = ?`).get(job_id);
+      if (job) {
+        this.upsertTimer(job.job_id, job.name, job.frequency, job);
+        console.log(`[CronScheduler] Job ${job_id} restarted.`);
+        return true;
+      }
+      return false;
+    } catch (e) {
+      console.error(`[Restart Job Error] ${job_id}:`, e.message);
+      return false;
+    }
+  }
+
+  deleteJob(job_id) {
+    this.db.prepare(`DELETE FROM jobs WHERE job_id = ?`).run(job_id);
+    if (schedule.scheduledJobs[job_id]) schedule.scheduledJobs[job_id].cancel();
+    return true;
+  }
+
+  getAllJobs(project_id) {
+    const jobs = this.db.prepare(`SELECT * FROM jobs WHERE project_id = ?`).all(project_id);
+    return jobs.map(job => ({
+      ..._.omit(job, ['cases']),
+      status: job.is_cancel === 0 ? 0 : 1,
+      next_run_time: this.getNextExecutionTime(this.convertToCron(job.frequency)),
+      runners: JSON5.parse(job.cases || '[]').map(v => v?.option?.testing_id)
+    }));
+  }
+
+  convertToCron(freq) {
+    const data = typeof freq === 'string' ? JSON5.parse(freq) : freq;
+    if (data.type === 'cron') {
+      const exp = data.cron?.expression || '0 0 * * *';
+      const parts = exp.trim().split(/\s+/);
+      return parts.length === 5 ? `0 ${exp}` : exp;
+    }
+    if (data.type === 'preset') {
+      const { cycle, config } = data.preset;
+      const [h, m] = (config.time || "0:0").split(':');
+      if (cycle === 'minute') return `0 */${config.interval} * * * *`;
+      if (cycle === 'hour') return `0 0 */${config.interval} * * *`;
+      if (cycle === 'day') return `0 ${parseInt(m)} ${parseInt(h)} * * *`;
+      if (cycle === 'week') return `0 ${parseInt(m)} ${parseInt(h)} * * ${Array.isArray(config.weekdays) ? config.weekdays.join(',') : '*'}`;
+    }
+    return '0 0 0 * * *';
+  }
+
+  getNextExecutionTime(cron) {
+    try {
+      const { CronExpressionParser } = require('cron-parser');
+      return CronExpressionParser.parse(cron, { tz: 'Asia/Shanghai' }).next().getTime();
+    } catch (e) { return '-'; }
+  }
+}
+
+module.exports = CronScheduler;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "echoapi-cron-scheduler-batch",
-  "version": "1.0.10",
+  "version": "1.0.12",
   "description": "",
   "main": "index.js",
   "scripts": {