rl-rockcli 0.0.2 → 0.0.4

package/commands/sandbox/replay/history-fetcher.js

@@ -1,118 +0,0 @@
-const { fetchHistoryData } = require('../../log/history');
-const logger = require('../../../utils/logger');
-
-/**
- * 历史获取器
- * 封装 log history 的调用逻辑，支持批量并发获取
- */
-class HistoryFetcher {
-  /**
-   * 获取单个沙箱的历史
-   * @param {string} sandboxId - 沙箱 ID
-   * @param {Object} options - 选项
-   * @param {string} options.cluster - 集群名称
-   * @param {Array<string>} options.uris - URI 过滤器
-   * @param {boolean} options.debug - 是否开启调试
-   * @returns {Promise<Object>} - 历史数据（与 --dump 模式相同的格式）
-   */
-  async fetch(sandboxId, options = {}) {
-    const { cluster, uris, debug } = options;
-
-    const result = await fetchHistoryData(sandboxId, {
-      cluster,
-      uris,
-      debug
-    });
-
-    return result;
-  }
-
-  /**
-   * 批量获取历史（并发控制）
-   * @param {SandboxTask[]} tasks - 任务列表
-   * @param {number} concurrency - 并发数
-   * @param {Object} options - 选项
-   * @param {boolean} options.quiet - 静默模式
-   * @param {Function} options.onProgress - 进度回调
-   * @returns {Promise<void>}
-   */
-  async fetchBatch(tasks, concurrency, options = {}) {
-    const { quiet, onProgress } = options;
-
-    // 过滤出需要获取历史的任务（没有预加载 requests 的）
-    const tasksToFetch = tasks.filter(task => !task.hasRequests());
-
-    if (tasksToFetch.length === 0) {
-      if (!quiet) {
-        logger.info('All sandboxes have pre-loaded requests, skipping history fetch.');
-      }
-      // 标记所有任务为 ready
-      tasks.forEach(task => {
-        if (task.hasRequests()) {
-          task.status = 'ready';
-        }
-      });
-      return;
-    }
-
-    if (!quiet) {
-      logger.info(`Fetching history for ${tasksToFetch.length} sandboxes (concurrency: ${concurrency})...`);
-    }
-
-    // 创建任务队列
-    const queue = [...tasksToFetch];
-    let completed = 0;
-
-    // Worker 函数
-    const worker = async () => {
-      while (queue.length > 0) {
-        const task = queue.shift();
-        if (!task) break;
-
-        task.startHistoryFetch();
-
-        try {
-          const historyData = await this.fetch(task.sandboxId, {
-            cluster: task.cluster,
-            uris: task.uris
-          });
-
-          task.completeHistoryFetch(historyData);
-        } catch (error) {
-          task.failHistoryFetch(error);
-        }
-
-        completed++;
-        onProgress?.(completed, tasksToFetch.length, task);
-      }
-    };
-
-    // 启动并发 workers
-    const workers = [];
-    const actualConcurrency = Math.min(concurrency, tasksToFetch.length);
-
-    for (let i = 0; i < actualConcurrency; i++) {
-      workers.push(worker());
-    }
-
-    // 等待所有 workers 完成
-    await Promise.allSettled(workers);
-
-    // 标记预加载的任务为 ready
-    tasks.forEach(task => {
-      if (task.hasRequests() && task.status === 'pending') {
-        task.status = 'ready';
-      }
-    });
-
-    // 汇总结果
-    const succeeded = tasks.filter(t => t.status === 'ready').length;
-    const failed = tasks.filter(t => t.status === 'failed').length;
-
-    if (!quiet) {
-      logger.info(`History fetch completed: ${succeeded} succeeded, ${failed} failed.`);
-    }
-  }
-}
-
-module.exports = { HistoryFetcher };

package/commands/sandbox/replay/index.js

@@ -1,338 +0,0 @@
-const fs = require('fs-extra');
-const path = require('path');
-const logger = require('../../../utils/logger');
-const { RequestAnalyzer } = require('./analyzer');
-const { ReplayExecutor } = require('./executor');
-const {
-  displayAnalysisSummary,
-  displayResultsSummary,
-  displayDryRunSummary
-} = require('./display');
-const { ConcurrentReplayOrchestrator } = require('./concurrent-orchestrator');
-const { displayConcurrentResultsSummary } = require('./concurrent-display');
-const { BatchReplayOrchestrator } = require('./batch-orchestrator');
-const { gracefulExit } = require('../../../utils/execution_logger');
-
-/**
- * 从 stdin 读取数据
- * @returns {Promise<string>}
- */
-function readStdin() {
-  return new Promise((resolve, reject) => {
-    let data = '';
-    process.stdin.setEncoding('utf8');
-
-    process.stdin.on('data', (chunk) => {
-      data += chunk;
-    });
-
-    process.stdin.on('end', () => {
-      resolve(data);
-    });
-
-    process.stdin.on('error', (error) => {
-      reject(new Error(`Error reading from stdin: ${error.message}`));
-    });
-  });
-}
-
-/**
- * 解析请求数据
- * @param {string} inputData - JSON 字符串
- * @returns {Object[]} 请求列表
- */
-function parseRequests(inputData) {
-  let data;
-  try {
-    data = JSON.parse(inputData);
-  } catch (parseError) {
-    throw new Error(`Failed to parse JSON from stdin: ${parseError.message}`);
-  }
-
-  if (!data.requests || !Array.isArray(data.requests)) {
-    throw new Error('Invalid input format: "requests" array is required');
-  }
-
-  return data.requests;
-}
-
-/**
- * 处理 replay 命令
- * @param {Object} argv - 命令行参数
- * @param {Object} client - SandboxClient 实例
- */
-async function handleSmartReplay(argv, client) {
-  // 检查是否为批量模式
-  if (argv.fromFile) {
-    return handleBatchReplay(argv, client);
-  }
-
-  // 检查是否为目录模式
-  if (argv.fromDir) {
-    return handleDirectoryReplay(argv, client);
-  }
-
-  // 1. 读取并解析输入
-  const inputData = await readStdin();
-  const requests = parseRequests(inputData);
-
-  if (requests.length === 0) {
-    logger.info('No requests to replay');
-    return;
-  }
-
-  // 2. 分析请求
-  const analyzer = new RequestAnalyzer({
-    mode: argv.mode || 'smart',
-    filters: argv.filter || [],
-    executeStop: argv.stop || false
-  });
-
-  const plan = analyzer.analyze(requests);
-
-  // 3. 显示分析摘要
-  displayAnalysisSummary(plan, {
-    mode: argv.mode || 'smart',
-    quiet: argv.quiet || false
-  });
-
-  // 4. 预演模式
-  if (argv.dryRun) {
-    displayDryRunSummary(plan);
-    logger.info('Dry run completed - no requests were executed');
-    return;
-  }
-
-  // 5. 检查是否有请求需要执行
-  if (plan.executeCount === 0) {
-    logger.info('No requests to execute after filtering');
-    return;
-  }
-
-  // 6. 检查并发模式
-  const concurrency = argv.concurrency || 1;
-
-  if (concurrency > 1) {
-    // === 并发回放路径 ===
-    const orchestrator = new ConcurrentReplayOrchestrator({
-      concurrency: concurrency,
-      config: client.config,
-      quiet: argv.quiet || false,
-      logFile: argv.logFile || 'replay.log',
-      failureStrategy: argv.failureStrategy || 'continue'
-    });
-
-    const result = await orchestrator.execute(plan, {
-      timing: argv.timing || 'none',
-      interval: argv.interval || 5,
-      quiet: argv.quiet || false,
-      logFile: argv.logFile || 'replay.log'
-    });
-
-    // 显示并发结果摘要
-    displayConcurrentResultsSummary(result, {
-      quiet: argv.quiet || false
-    });
-
-    // 设置退出码
-    if (!result.allSucceeded || result.aggregated.failed > 0) {
-      process.exitCode = 1;
-    }
-
-  } else {
-    // === 原有单沙箱回放路径 ===
-    const executor = new ReplayExecutor(client, {
-      timing: argv.timing || 'none',
-      interval: argv.interval || 5,
-      quiet: argv.quiet || false,
-      logFile: argv.logFile || 'replay.log',
-      verboseLog: argv.verboseLog || false,
-      plan: plan
-    });
-
-    const results = await executor.execute(plan);
-
-    // 显示结果摘要
-    displayResultsSummary(results, [], {
-      quiet: argv.quiet || false,
-      logFile: argv.logFile || 'replay.log',
-      sandboxId: executor.currentSandboxId
-    });
-
-    // 如果有失败，设置退出码
-    if (results.failed > 0) {
-      process.exitCode = 1;
-    }
-  }
-}
-
-/**
- * 处理批量回放命令
- * @param {Object} argv - 命令行参数
- * @param {Object} client - SandboxClient 实例
- */
-async function handleBatchReplay(argv, client) {
-  const orchestrator = new BatchReplayOrchestrator({
-    concurrency: argv.concurrency || 1,
-    baseConfig: client.config,
-    mode: argv.mode || 'smart',
-    timing: argv.timing || 'none',
-    interval: argv.interval || 5,
-    filters: argv.filter || [],
-    autoFetchHistory: argv.autoFetchHistory !== false,
-    continueOnError: argv.continueOnSandboxError !== false,
-    quiet: argv.quiet || false,
-    dryRun: argv.dryRun || false,
-    executeStop: argv.stop || false,
-    reportFile: argv.reportFile || 'batch-replay-report.json',
-    logFileBase: argv.logFile || 'replay.log',
-    verboseLog: argv.verboseLog || false
-  });
-
-  const result = await orchestrator.execute(argv.fromFile);
-
-  // 设置退出码
-  if (result.summary.failed > 0) {
-    process.exitCode = 1;
-  }
-
-  return result;
-}
-
-/**
- * 处理目录模式批量回放
- * @param {Object} argv - 命令行参数
- * @param {Object} client - SandboxClient 实例
- */
-async function handleDirectoryReplay(argv, client) {
-  const sourceDir = argv.fromDir;
-
-  // 1. 验证目录存在
-  if (!fs.existsSync(sourceDir)) {
-    logger.error(`Directory not found: ${sourceDir}`);
-    gracefulExit(1);
-  }
-
-  // 2. 读取 manifest.json（如果存在）
-  const manifestPath = path.join(sourceDir, 'manifest.json');
-  let manifest = null;
-  let historyFiles = [];
-
-  if (fs.existsSync(manifestPath)) {
-    try {
-      manifest = fs.readJsonSync(manifestPath);
-    } catch (error) {
-      logger.warn(`Failed to read manifest.json: ${error.message}`);
-    }
-  }
-
-  // 3. 扫描目录中的 JSON 文件
-  const files = fs.readdirSync(sourceDir);
-  historyFiles = files.filter(f =>
-    f.endsWith('.json') &&
-    f !== 'manifest.json' &&
-    !f.startsWith('.')
-  );
-
-  if (historyFiles.length === 0) {
-    logger.error(`No history files found in ${sourceDir}`);
-    gracefulExit(1);
-  }
-
-  // 4. 构建输入数据（模拟 --from-file 格式）
-  const sandboxes = [];
-  const loadErrors = [];
-
-  for (const file of historyFiles) {
-    const filePath = path.join(sourceDir, file);
-    try {
-      const data = fs.readJsonSync(filePath);
-
-      if (!data.sandboxId) {
-        loadErrors.push({ file, error: 'Missing sandboxId' });
-        continue;
-      }
-
-      if (!data.requests || !Array.isArray(data.requests)) {
-        loadErrors.push({ file, error: 'Missing or invalid requests array' });
-        continue;
-      }
-
-      sandboxes.push(data);
-    } catch (error) {
-      loadErrors.push({ file, error: error.message });
-    }
-  }
-
-  if (!argv.quiet) {
-    console.log('\n' + '═'.repeat(70));
-    console.log('📂 Directory Replay Mode');
-    console.log('═'.repeat(70));
-    console.log(`   Source Dir:  ${sourceDir}`);
-    console.log(`   Files Found: ${historyFiles.length}`);
-    console.log(`   Valid:       ${sandboxes.length}`);
-    if (loadErrors.length > 0) {
-      console.log(`   Errors:      ${loadErrors.length}`);
-      loadErrors.slice(0, 5).forEach(e => {
-        console.log(`     - ${e.file}: ${e.error}`);
-      });
-      if (loadErrors.length > 5) {
-        console.log(`     ... and ${loadErrors.length - 5} more`);
-      }
-    }
-    console.log('═'.repeat(70) + '\n');
-  }
-
-  if (sandboxes.length === 0) {
-    logger.error('No valid sandbox histories found');
-    gracefulExit(1);
-  }
-
-  // 5. 构建虚拟输入文件并调用批量回放
-  const inputData = {
-    metadata: {
-      ...(manifest?.metadata || {}),
-      sourceDir: sourceDir,
-      loadedAt: new Date().toISOString()
-    },
-    defaults: manifest?.defaults || {},
-    sandboxes: sandboxes
-  };
-
-  // 创建临时文件
-  const tempFile = path.join(sourceDir, '.replay-input-temp.json');
-  try {
-    await fs.writeJson(tempFile, inputData, { spaces: 2 });
-
-    // 使用批量回放处理（强制禁用自动获取历史）
-    const modifiedArgv = {
-      ...argv,
-      fromFile: tempFile,
-      autoFetchHistory: false  // 已经有预加载的 requests
-    };
-
-    const result = await handleBatchReplay(modifiedArgv, client);
-
-    // 清理临时文件
-    await fs.remove(tempFile);
-
-    return result;
-  } catch (error) {
-    // 确保清理临时文件
-    if (fs.existsSync(tempFile)) {
-      await fs.remove(tempFile);
-    }
-    throw error;
-  }
-}
-
-module.exports = {
-  handleSmartReplay,
-  handleBatchReplay,
-  handleDirectoryReplay,
-  readStdin,
-  parseRequests,
-  RequestAnalyzer,
-  ReplayExecutor,
-  BatchReplayOrchestrator
-};

package/commands/sandbox/replay/pid-mapping.js

@@ -1,26 +0,0 @@
-/**
- * 从 nohup 输出中提取 PID
- * SDK 使用 PIDSTART{pid}PIDEND 格式
- * @param {string} output - 命令输出
- * @returns {string|null} 提取的 PID，如果未找到则返回 null
- */
-function extractPidFromOutput(output) {
-  if (!output) return null;
-
-  const match = output.match(/PIDSTART(\d+)PIDEND/);
-  if (match) {
-    return match[1];
-  }
-
-  // 备用方案：尝试匹配 [1] 12345 格式
-  const bgMatch = output.match(/\[\d+\]\s+(\d+)/);
-  if (bgMatch) {
-    return bgMatch[1];
-  }
-
-  return null;
-}
-
-module.exports = {
-  extractPidFromOutput
-};

package/commands/sandbox/replay/request.js

@@ -1,109 +0,0 @@
-/**
- * 请求分类常量
- */
-const RequestCategory = {
-  STARTUP: 'startup',                  // start_async
-  STARTUP_POLLING: 'startup_polling',  // get_status after start
-  SESSION: 'session',                  // create_session, close_session
-  NOHUP_COMMAND: 'nohup_command',      // nohup xxx &
-  PROCESS_CHECK: 'process_check',      // kill -0 {pid}
-  LOG_QUERY: 'log_query',              // head -c xxx file
-  UPLOAD: 'upload',                    // upload file
-  STOP: 'stop',                        // stop sandbox
-  OTHER: 'other'                       // other commands
-};
-
-/**
- * 处理动作常量
- */
-const RequestAction = {
-  EXECUTE: 'execute',                              // 执行
-  SKIP: 'skip',                                    // 跳过
-  MERGE: 'merge',                                  // 合并到等待逻辑
-  EXECUTE_WITH_PROCESS_WAIT: 'execute_with_process_wait'   // 执行 nohup 并等待进程结束
-};
-
-/**
- * 单个回放请求
- */
-class ReplayRequest {
-  constructor(raw, index) {
-    this.index = index;
-    this.method = raw.method;
-    this.uri = raw.uri;
-    this.requestBody = raw.requestBody || {};
-    this.headers = raw.headers || {};
-    this.responseTime = raw.responseTime ? new Date(raw.responseTime) : null;
-
-    // 分析后填充的字段
-    this.category = null;       // 请求分类
-    this.action = null;         // 处理动作
-    this.skipReason = null;     // 跳过原因
-  }
-
-  /**
-   * 获取命令（如果是 run_in_session 请求）
-   */
-  getCommand() {
-    return this.requestBody?.command || '';
-  }
-
-  /**
-   * 获取简短描述
-   */
-  getShortDescription(maxLen = 60) {
-    const command = this.getCommand();
-    if (command) {
-      if (command.length > maxLen) {
-        return command.substring(0, maxLen - 3) + '...';
-      }
-      return command;
-    }
-    return this.uri.split('?')[0].split('/').pop();
-  }
-}
-
-/**
- * 回放计划
- */
-class ReplayPlan {
-  constructor() {
-    this.originalCount = 0;       // 原始请求数
-    this.requests = [];           // 待执行的请求列表
-    this.skippedRequests = [];    // 被跳过的请求列表
-    this.mergedRequests = [];     // 被合并的请求列表
-
-    // 统计信息
-    this.stats = {
-      startup: 0,
-      startupPolling: 0,
-      session: 0,
-      nohupCommand: 0,
-      processCheck: 0,
-      logQuery: 0,
-      upload: 0,
-      stop: 0,
-      other: 0
-    };
-
-  }
-
-  get skippedCount() {
-    return this.skippedRequests.length;
-  }
-
-  get mergedCount() {
-    return this.mergedRequests.length;
-  }
-
-  get executeCount() {
-    return this.requests.length;
-  }
-}
-
-module.exports = {
-  RequestCategory,
-  RequestAction,
-  ReplayRequest,
-  ReplayPlan
-};