rl-rockcli 0.0.1 → 0.0.2

package/commands/sandbox/replay/batch-task.js

@@ -0,0 +1,369 @@
+/**
+ * 批量回放任务状态常量
+ */
+const TaskStatus = {
+  PENDING: 'pending',         // 待处理
+  FETCHING: 'fetching',       // 正在获取历史
+  READY: 'ready',             // 历史已就绪，待执行
+  RUNNING: 'running',         // 正在执行回放
+  COMPLETED: 'completed',     // 执行完成
+  FAILED: 'failed',           // 执行失败
+  SKIPPED: 'skipped'          // 跳过（历史获取失败等）
+};
+
+/**
+ * 错误发生阶段
+ */
+const ErrorPhase = {
+  PARSE: 'parse',              // 解析输入
+  HISTORY_FETCH: 'history_fetch', // 获取历史
+  REPLAY: 'replay'             // 执行回放
+};
+
+/**
+ * 单个沙箱任务
+ * 管理单个沙箱的回放状态和结果
+ */
+class SandboxTask {
+  /**
+   * @param {number} index - 任务索引（0-based）
+   * @param {Object} sandboxConfig - 沙箱配置
+   * @param {Object} defaults - 默认配置（从输入文件的 defaults 字段）
+   */
+  constructor(index, sandboxConfig, defaults = {}) {
+    this.index = index;
+    this.sandboxId = sandboxConfig.sandboxId;
+    this.name = sandboxConfig.name || sandboxConfig.sandboxId.substring(0, 8);
+
+    // 合并配置（沙箱配置覆盖默认配置）
+    this.cluster = sandboxConfig.cluster || defaults.cluster || null;
+    this.userId = sandboxConfig.userId || defaults.userId || null;
+    this.experimentId = sandboxConfig.experimentId || defaults.experimentId || null;
+    this.mode = sandboxConfig.mode || defaults.mode || 'smart';
+    this.timing = sandboxConfig.timing || defaults.timing || 'none';
+
+    // 元数据
+    this.tags = sandboxConfig.tags || {};
+    this.uris = sandboxConfig.uris || [];
+
+    // 合并过滤器（默认 + 沙箱特定）
+    this.filters = [
+      ...(defaults.filters || []),
+      ...(sandboxConfig.filters || [])
+    ];
+
+    // 状态
+    this.status = TaskStatus.PENDING;
+
+    // 历史数据
+    this.requests = sandboxConfig.requests || null;  // 预加载的请求列表
+    this.historyData = null;  // 完整的历史数据（包含 startParams, targetCluster 等）
+
+    // 回放结果
+    this.newSandboxId = null;  // 新创建的沙箱 ID
+    this.replayResult = null;  // ReplayExecutor 返回的结果
+    this.pidMappings = [];     // PID 映射表
+
+    // 错误信息
+    this.error = null;
+    this.errorPhase = null;
+
+    // 时间记录
+    this.historyFetchStartTime = null;
+    this.historyFetchEndTime = null;
+    this.replayStartTime = null;
+    this.replayEndTime = null;
+
+    // 日志文件
+    this.logFile = null;
+  }
+
+  /**
+   * 是否有预加载的请求列表
+   * @returns {boolean}
+   */
+  hasRequests() {
+    return !!(this.requests && Array.isArray(this.requests) && this.requests.length > 0);
+  }
+
+  /**
+   * 设置历史获取开始
+   */
+  startHistoryFetch() {
+    this.status = TaskStatus.FETCHING;
+    this.historyFetchStartTime = Date.now();
+  }
+
+  /**
+   * 设置历史获取完成
+   * @param {Object} historyData - 历史数据
+   */
+  completeHistoryFetch(historyData) {
+    this.historyData = historyData;
+    this.requests = historyData.requests || [];
+    this.status = TaskStatus.READY;
+    this.historyFetchEndTime = Date.now();
+  }
+
+  /**
+   * 设置历史获取失败
+   * @param {Error} error - 错误对象
+   */
+  failHistoryFetch(error) {
+    this.status = TaskStatus.FAILED;
+    this.error = error.message || String(error);
+    this.errorPhase = ErrorPhase.HISTORY_FETCH;
+    this.historyFetchEndTime = Date.now();
+  }
+
+  /**
+   * 设置回放开始
+   */
+  startReplay() {
+    this.status = TaskStatus.RUNNING;
+    this.replayStartTime = Date.now();
+  }
+
+  /**
+   * 设置回放完成
+   * @param {Object} result - 回放结果
+   * @param {string} newSandboxId - 新沙箱 ID
+   * @param {Array} pidMappings - PID 映射
+   */
+  completeReplay(result, newSandboxId, pidMappings = []) {
+    // 如果有失败的请求，标记为 FAILED 而不是 COMPLETED
+    if (result && result.failed > 0) {
+      this.status = TaskStatus.FAILED;
+      this.error = `${result.failed} request(s) failed during replay`;
+      this.errorPhase = ErrorPhase.REPLAY;
+    } else {
+      this.status = TaskStatus.COMPLETED;
+    }
+    this.replayResult = result;
+    this.newSandboxId = newSandboxId;
+    this.pidMappings = pidMappings;
+    this.replayEndTime = Date.now();
+  }
+
+  /**
+   * 设置回放失败
+   * @param {Error} error - 错误对象
+   */
+  failReplay(error) {
+    this.status = TaskStatus.FAILED;
+    this.error = error.message || String(error);
+    this.errorPhase = ErrorPhase.REPLAY;
+    this.replayEndTime = Date.now();
+  }
+
+  /**
+   * 获取历史获取耗时（毫秒）
+   * @returns {number|null}
+   */
+  getHistoryFetchDuration() {
+    if (this.historyFetchStartTime && this.historyFetchEndTime) {
+      return this.historyFetchEndTime - this.historyFetchStartTime;
+    }
+    return null;
+  }
+
+  /**
+   * 获取回放耗时（毫秒）
+   * @returns {number|null}
+   */
+  getReplayDuration() {
+    if (this.replayStartTime && this.replayEndTime) {
+      return this.replayEndTime - this.replayStartTime;
+    }
+    return null;
+  }
+
+  /**
+   * 转换为结果对象
+   * @returns {SandboxResult}
+   */
+  toResult() {
+    return new SandboxResult(this);
+  }
+}
+
+/**
+ * 单个沙箱的执行结果
+ */
+class SandboxResult {
+  /**
+   * @param {SandboxTask} task - 任务对象
+   */
+  constructor(task) {
+    this.index = task.index;
+    this.sandboxId = task.sandboxId;
+    this.name = task.name;
+    this.tags = task.tags;
+    this.status = task.status;
+    this.newSandboxId = task.newSandboxId;
+
+    // 历史获取结果
+    this.historyFetch = {
+      success: task.status !== TaskStatus.FAILED || task.errorPhase !== ErrorPhase.HISTORY_FETCH,
+      requestCount: task.requests ? task.requests.length : 0,
+      duration: task.getHistoryFetchDuration(),
+      error: task.errorPhase === ErrorPhase.HISTORY_FETCH ? task.error : null
+    };
+
+    // 回放结果
+    if (task.replayResult) {
+      this.replay = {
+        originalRequests: task.replayResult.total || 0,
+        executedRequests: (task.replayResult.success || 0) + (task.replayResult.failed || 0),
+        success: task.replayResult.success || 0,
+        failed: task.replayResult.failed || 0,
+        skipped: task.replayResult.skipped || 0,
+        duration: task.getReplayDuration()
+      };
+    } else {
+      this.replay = null;
+    }
+
+    // PID 映射
+    this.pidMappings = task.pidMappings;
+
+    // 错误信息
+    this.errors = [];
+    if (task.error) {
+      this.errors.push({
+        phase: task.errorPhase,
+        message: task.error
+      });
+    }
+
+    // 日志文件
+    this.logFile = task.logFile;
+  }
+}
+
+/**
+ * 批量回放结果汇总
+ */
+class BatchReplayResult {
+  /**
+   * @param {Object} options - 配置选项
+   */
+  constructor(options = {}) {
+    this.summary = {
+      totalSandboxes: 0,
+      successful: 0,
+      failed: 0,
+      skipped: 0,
+      startTime: null,
+      endTime: null,
+      totalDuration: null,
+      concurrency: options.concurrency || 1
+    };
+
+    this.sandboxResults = [];
+    this.failedSandboxes = [];
+
+    this.metadata = {
+      inputFile: options.inputFile || null,
+      inputMetadata: options.inputMetadata || null,
+      cliVersion: options.cliVersion || null,
+      mode: options.mode || 'smart',
+      timing: options.timing || 'none'
+    };
+  }
+
+  /**
+   * 设置开始时间
+   */
+  start() {
+    this.summary.startTime = new Date().toISOString();
+  }
+
+  /**
+   * 设置结束时间并计算总耗时
+   */
+  end() {
+    this.summary.endTime = new Date().toISOString();
+
+    if (this.summary.startTime && this.summary.endTime) {
+      const startMs = new Date(this.summary.startTime).getTime();
+      const endMs = new Date(this.summary.endTime).getTime();
+      const durationMs = endMs - startMs;
+      this.summary.totalDuration = formatDuration(durationMs);
+    }
+  }
+
+  /**
+   * 添加沙箱结果
+   * @param {SandboxResult} result - 沙箱结果
+   */
+  addResult(result) {
+    this.sandboxResults.push(result);
+    this.summary.totalSandboxes++;
+
+    if (result.status === TaskStatus.COMPLETED) {
+      this.summary.successful++;
+    } else if (result.status === TaskStatus.FAILED) {
+      this.summary.failed++;
+      this.failedSandboxes.push({
+        sandboxId: result.sandboxId,
+        name: result.name,
+        error: result.errors.length > 0 ? result.errors[0].message : 'Unknown error',
+        phase: result.errors.length > 0 ? result.errors[0].phase : 'unknown'
+      });
+    } else if (result.status === TaskStatus.SKIPPED) {
+      this.summary.skipped++;
+    }
+  }
+
+  /**
+   * 从任务列表生成结果
+   * @param {SandboxTask[]} tasks - 任务列表
+   */
+  generateFromTasks(tasks) {
+    for (const task of tasks) {
+      this.addResult(task.toResult());
+    }
+  }
+
+  /**
+   * 转换为 JSON 对象
+   * @returns {Object}
+   */
+  toJSON() {
+    return {
+      summary: this.summary,
+      sandboxResults: this.sandboxResults,
+      failedSandboxes: this.failedSandboxes,
+      metadata: this.metadata
+    };
+  }
+}
+
+/**
+ * 格式化持续时间
+ * @param {number} ms - 毫秒
+ * @returns {string}
+ */
+function formatDuration(ms) {
+  if (ms === null || ms === undefined) return '-';
+
+  if (ms < 1000) {
+    return `${ms}ms`;
+  } else if (ms < 60000) {
+    return `${(ms / 1000).toFixed(1)}s`;
+  } else {
+    const minutes = Math.floor(ms / 60000);
+    const seconds = Math.floor((ms % 60000) / 1000);
+    return `${minutes}m ${seconds}s`;
+  }
+}
+
+module.exports = {
+  TaskStatus,
+  ErrorPhase,
+  SandboxTask,
+  SandboxResult,
+  BatchReplayResult,
+  formatDuration
+};

package/commands/sandbox/replay/concurrent-display.js

@@ -0,0 +1,70 @@
+/**
+ * 格式化持续时间
+ * @param {number} ms - 毫秒
+ * @returns {string}
+ */
+function formatDuration(ms) {
+  if (ms == null || isNaN(ms)) return 'N/A';
+  if (ms < 1000) return `${ms}ms`;
+  if (ms < 60000) return `${(ms / 1000).toFixed(1)}s`;
+  const minutes = Math.floor(ms / 60000);
+  const seconds = Math.round((ms % 60000) / 1000);
+  return `${minutes}m${seconds}s`;
+}
+
+/**
+ * 显示并发回放结果摘要
+ * @param {ConcurrentReplayResult} result
+ * @param {Object} options
+ * @param {boolean} options.quiet - 静默模式
+ */
+function displayConcurrentResultsSummary(result, options = {}) {
+  if (options.quiet) return;
+
+  console.log('\n═══════════════════════════════════════════════════════════════');
+  console.log('📊 Concurrent Replay Summary');
+  console.log('═══════════════════════════════════════════════════════════════');
+
+  console.log(`\nConcurrency: ${result.concurrency} sandboxes`);
+  console.log(`Status: ${result.allSucceeded ? '✅ All succeeded' : '⚠️  Some failed'}`);
+
+  // 显示每个 worker 的结果
+  console.log('\nPer-Sandbox Results:');
+  console.log('┌─────────┬────────────────────────────────────────┬─────────┬─────────┬─────────┐');
+  console.log('│ Worker  │ Sandbox ID                             │ Success │ Failed  │ Duration│');
+  console.log('├─────────┼────────────────────────────────────────┼─────────┼─────────┼─────────┤');
+
+  result.workers.forEach(w => {
+    const status = w.status === 'completed' ? '✅' : '❌';
+    const sandboxId = (w.sandboxId || 'N/A').padEnd(38).substring(0, 38);
+    const success = String(w.results?.success || 0).padStart(7);
+    const failed = String(w.results?.failed || 0).padStart(7);
+    const duration = formatDuration(w.duration).padStart(7);
+
+    console.log(`│ ${status} ${String(w.workerId).padEnd(5)} │ ${sandboxId} │ ${success} │ ${failed} │ ${duration} │`);
+
+    if (w.error) {
+      const errorMsg = w.error.length > 60 ? w.error.substring(0, 57) + '...' : w.error;
+      console.log(`│         │   Error: ${errorMsg.padEnd(52)} │`);
+    }
+  });
+
+  console.log('└─────────┴────────────────────────────────────────┴─────────┴─────────┴─────────┘');
+
+  // 显示汇总
+  console.log('\nAggregated Results:');
+  console.log(`├── ✅ Total Successful: ${result.aggregated.success}`);
+  console.log(`├── ❌ Total Failed: ${result.aggregated.failed}`);
+  console.log(`└── ⏭️  Total Skipped: ${result.aggregated.skipped}`);
+
+  // 显示日志文件
+  console.log('\nLog Files:');
+  result.workers.forEach((w, index) => {
+    const prefix = index === result.workers.length - 1 ? '└──' : '├──';
+    console.log(`${prefix} Worker ${w.workerId}: ${w.logFile}`);
+  });
+
+  console.log('═══════════════════════════════════════════════════════════════\n');
+}
+
+module.exports = { displayConcurrentResultsSummary, formatDuration };

package/commands/sandbox/replay/concurrent-orchestrator.js

@@ -0,0 +1,170 @@
+const { ReplayWorker } = require('./worker');
+
+/**
+ * 并发回放协调器
+ * 管理多个 ReplayWorker 的并发执行
+ */
+class ConcurrentReplayOrchestrator {
+  /**
+   * @param {Object} options
+   * @param {number} options.concurrency - 并发数
+   * @param {Object} options.config - 沙箱配置
+   * @param {boolean} options.quiet - 静默模式
+   * @param {string} options.logFile - 日志文件基础路径
+   * @param {string} options.failureStrategy - 失败策略: 'continue' | 'stop-all'
+   */
+  constructor(options) {
+    this.concurrency = options.concurrency || 1;
+    this.config = options.config;
+    this.quiet = options.quiet || false;
+    this.logFile = options.logFile || 'replay.log';
+    this.failureStrategy = options.failureStrategy || 'continue';
+
+    this.workers = [];
+    this.progressIntervalId = null;
+  }
+
+  /**
+   * 执行并发回放
+   * @param {ReplayPlan} plan - 回放计划
+   * @param {Object} executorOptions - 执行器选项
+   * @returns {Promise<ConcurrentReplayResult>}
+   */
+  async execute(plan, executorOptions) {
+    // 1. 显示并发回放摘要
+    this.displayConcurrentSummary(plan);
+
+    // 2. 创建所有 workers
+    for (let i = 1; i <= this.concurrency; i++) {
+      const worker = new ReplayWorker(i, this.config, plan, {
+        ...executorOptions,
+        logFile: this.logFile
+      });
+      this.workers.push(worker);
+    }
+
+    // 3. 启动进度监控（如果非静默模式）
+    if (!this.quiet) {
+      this.startProgressMonitor();
+    }
+
+    // 4. 并发执行所有 workers
+    let workerResults;
+
+    if (this.failureStrategy === 'stop-all') {
+      // 使用 Promise.all，任一失败则全部停止
+      try {
+        workerResults = await Promise.all(
+          this.workers.map(w => w.execute())
+        );
+      } catch (error) {
+        // 如果 Promise.all 抛出异常，收集已有结果
+        workerResults = this.workers.map(w => w.getWorkerResult());
+      }
+    } else {
+      // 使用 Promise.allSettled，允许部分失败
+      const settled = await Promise.allSettled(
+        this.workers.map(w => w.execute())
+      );
+      workerResults = settled.map((result, index) => {
+        if (result.status === 'fulfilled') {
+          return result.value;
+        } else {
+          return this.workers[index].getWorkerResult();
+        }
+      });
+    }
+
+    // 5. 停止进度监控
+    this.stopProgressMonitor();
+
+    // 6. 汇总结果
+    return this.aggregateResults(workerResults);
+  }
+
+  /**
+   * 显示并发回放摘要
+   * @param {ReplayPlan} plan
+   */
+  displayConcurrentSummary(plan) {
+    if (this.quiet) return;
+
+    console.log(`\n🔀 Concurrent Replay Mode`);
+    console.log(`   Concurrency: ${this.concurrency} sandboxes`);
+    console.log(`   Requests per sandbox: ${plan.executeCount}`);
+    console.log(`   Total requests: ${plan.executeCount * this.concurrency}`);
+    console.log(`\n⏳ Starting ${this.concurrency} sandboxes...\n`);
+  }
+
+  /**
+   * 启动进度监控
+   */
+  startProgressMonitor() {
+    this.progressIntervalId = setInterval(() => {
+      this.displayProgress();
+    }, 10000);  // 每 10 秒更新一次进度
+  }
+
+  /**
+   * 停止进度监控
+   */
+  stopProgressMonitor() {
+    if (this.progressIntervalId) {
+      clearInterval(this.progressIntervalId);
+      this.progressIntervalId = null;
+    }
+  }
+
+  /**
+   * 显示当前进度
+   */
+  displayProgress() {
+    const statuses = this.workers.map(w => {
+      const progress = w.getProgress();
+      const icon = progress.status === 'completed' ? '✅' :
+                   progress.status === 'failed' ? '❌' :
+                   progress.status === 'running' ? '⏳' : '⏸️';
+      const sandboxId = progress.sandboxId || '--------';
+      return `  Worker ${progress.workerId}: ${icon} sandbox=${sandboxId}... ${progress.success}/${progress.total}`;
+    });
+
+    console.log('\n--- Progress Update ---');
+    statuses.forEach(s => console.log(s));
+    console.log('-----------------------\n');
+  }
+
+  /**
+   * 汇总执行结果
+   * @param {WorkerResult[]} workerResults
+   * @returns {ConcurrentReplayResult}
+   */
+  aggregateResults(workerResults) {
+    const totalResults = {
+      total: 0,
+      success: 0,
+      failed: 0,
+      skipped: 0
+    };
+
+    workerResults.forEach(r => {
+      if (r.results) {
+        totalResults.total += r.results.total;
+        totalResults.success += r.results.success;
+        totalResults.failed += r.results.failed;
+        totalResults.skipped += r.results.skipped;
+      }
+    });
+
+    return {
+      concurrency: this.concurrency,
+      workers: workerResults,
+      aggregated: totalResults,
+      allSucceeded: workerResults.every(r => r.status === 'completed'),
+      sandboxIds: workerResults
+        .filter(r => r.sandboxId)
+        .map(r => ({ workerId: r.workerId, sandboxId: r.sandboxId }))
+    };
+  }
+}
+
+module.exports = { ConcurrentReplayOrchestrator };