rl-rockcli 0.0.2 → 0.0.3

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

@@ -1,369 +0,0 @@
-/**
- * 批量回放任务状态常量
- */
-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/core/replay/concurrent-display.js

@@ -1,70 +0,0 @@
-/**
- * 格式化持续时间
- * @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/core/replay/concurrent-orchestrator.js

@@ -1,170 +0,0 @@
-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 };

package/commands/sandbox/core/replay/data-source.js

@@ -1,86 +0,0 @@
-'use strict';
-
-/**
- * ReplayDataSource Interface
- * 
- * Abstract interface for fetching sandbox history data.
- * Different environments (internal/opensource) can implement this interface
- * with their own data sources (Loghouse, local files, cloud storage, etc.)
- */
-
-/**
- * @typedef {Object} HistoryRequest
- * @property {string} method - HTTP method (GET, POST, etc.)
- * @property {string} uri - Request URI
- * @property {Object} [requestBody] - Request body
- * @property {Object} [headers] - Request headers
- * @property {string} timestamp - Timestamp of the request
- */
-
-/**
- * @typedef {Object} HistoryData
- * @property {string} sandboxId - Sandbox ID
- * @property {HistoryRequest[]} requests - List of historical requests
- * @property {Object} [metadata] - Additional metadata (cluster, time range, etc.)
- */
-
-/**
- * Abstract base class for replay data sources
- * Subclasses must implement the fetch method
- */
-class ReplayDataSource {
-    /**
-     * Fetch history data for a sandbox
-     * @param {string} sandboxId - Sandbox ID
-     * @param {Object} options - Fetch options
-     * @param {string} [options.cluster] - Cluster name
-     * @param {Array<string>} [options.uris] - URI filters
-     * @param {boolean} [options.debug] - Enable debug mode
-     * @returns {Promise<HistoryData>} History data
-     * @throws {Error} If fetch fails
-     */
-    async fetch(sandboxId, options = {}) {
-        throw new Error('ReplayDataSource.fetch() must be implemented by subclass');
-    }
-
-    /**
-     * Batch fetch history data for multiple sandboxes
-     * @param {Array<{sandboxId: string, options: Object}>} requests - Fetch requests
-     * @param {number} [concurrency=5] - Concurrency limit
-     * @returns {Promise<Map<string, HistoryData>>} Map of sandboxId to history data
-     */
-    async fetchBatch(requests, concurrency = 5) {
-        const results = new Map();
-        const queue = [...requests];
-
-        const worker = async () => {
-            while (queue.length > 0) {
-                const item = queue.shift();
-                if (!item) break;
-
-                try {
-                    const data = await this.fetch(item.sandboxId, item.options);
-                    results.set(item.sandboxId, data);
-                } catch (error) {
-                    // Store error as metadata for failed fetches
-                    results.set(item.sandboxId, {
-                        sandboxId: item.sandboxId,
-                        requests: [],
-                        metadata: { error: error.message }
-                    });
-                }
-            }
-        };
-
-        const workers = Array(Math.min(concurrency, requests.length))
-            .fill(null)
-            .map(() => worker());
-
-        await Promise.all(workers);
-        return results;
-    }
-}
-
-module.exports = {
-    ReplayDataSource,
-};