rl-rockcli 0.0.7 → 0.0.8

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

@@ -1,124 +0,0 @@
-'use strict';
-
-const { ReplayDataSource } = require('./data-source');
-const { LoghouseDataSource } = require('./loghouse-data-source');
-const logger = require('../../../../utils/logger');
-
-// Default data source for internal environment
-const defaultDataSource = new LoghouseDataSource();
-
-/**
- * 历史获取器
- * 封装数据源调用逻辑，支持批量并发获取
- */
-class HistoryFetcher {
-  /**
-   * @param {ReplayDataSource} [dataSource] - 数据源实例（可选，默认使用 LoghouseDataSource）
-   */
-  constructor(dataSource = null) {
-    this.dataSource = dataSource || defaultDataSource;
-  }
-
-  /**
-   * 获取单个沙箱的历史
-   * @param {string} sandboxId - 沙箱 ID
-   * @param {Object} options - 选项
-   * @param {string} options.cluster - 集群名称
-   * @param {Array<string>} options.uris - URI 过滤器
-   * @param {boolean} options.debug - 是否开启调试
-   * @returns {Promise<Object>} - 历史数据
-   */
-  async fetch(sandboxId, options = {}) {
-    const result = await this.dataSource.fetch(sandboxId, options);
-    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/core/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/core/replay/loghouse-data-source.js

@@ -1,177 +0,0 @@
-'use strict';
-
-const { ReplayDataSource } = require('./data-source');
-const { createClient } = require('../../../../lib/log_provider');
-const { clusterTableMapping } = require('../../../log/core/utils');
-const logger = require('../../../../utils/logger');
-const path = require('path');
-const fs = require('fs');
-
-// Load internal log config
-const internalLogConfigPath = path.join(__dirname, '../../../config/internal_log_config.json');
-let internalLogConfig = { internalDomains: [], logFiles: {} };
-if (fs.existsSync(internalLogConfigPath)) {
-    try {
-        internalLogConfig = JSON.parse(fs.readFileSync(internalLogConfigPath, 'utf8'));
-    } catch (error) {
-        logger.warn(`Failed to load internal log config: ${error.message}`);
-    }
-}
-
-// Time ranges to search (in minutes)
-const TIME_RANGES = [30, 60, 120, 240, 480];
-
-/**
- * LoghouseDataSource - Internal implementation of ReplayDataSource
- * Fetches sandbox history data from Loghouse (internal log storage)
- */
-class LoghouseDataSource extends ReplayDataSource {
-    /**
-     * Fetch history data for a sandbox from Loghouse
-     * @param {string} sandboxId - Sandbox ID
-     * @param {Object} options - Fetch options
-     * @param {string} [options.cluster] - Cluster name (optional, will search all clusters if not specified)
-     * @param {Array<string>} [options.uris] - URI filters
-     * @param {boolean} [options.debug] - Enable debug mode
-     * @returns {Promise<HistoryData>} History data
-     */
-    async fetch(sandboxId, options = {}) {
-        const { cluster, uris, debug } = options;
-
-        // Determine clusters to query
-        let clustersToQuery = cluster
-            ? [cluster]
-            : Object.keys(clusterTableMapping.clusters);
-
-        const now = Date.now();
-        const requests = [];
-        let foundCluster = null;
-
-        // Query logs helper function
-        const queryLogs = async (queryOptions) => {
-            const { tableName, startTime, endTime, filter, limit } = queryOptions;
-            const mysqlClient = createClient();
-
-            try {
-                await mysqlClient.connect();
-                const logs = await mysqlClient.query({
-                    table: tableName,
-                    startTime,
-                    endTime,
-                    filter: filter || null,
-                    limit: limit || 1000,
-                    offset: 0,
-                    count: false,
-                    orderBy: '@timestamp',
-                    orderDirection: 'ASC'
-                });
-                return logs || [];
-            } catch (error) {
-                if (debug) {
-                    logger.error(`Query error: ${error.message}`);
-                }
-                return [];
-            } finally {
-                await mysqlClient.close();
-            }
-        };
-
-        // Search for sandbox execution logs across clusters and time ranges
-        for (const minutes of TIME_RANGES) {
-            const startTime = now - minutes * 60 * 1000;
-            const endTime = now;
-
-            for (const clusterName of clustersToQuery) {
-                const clusterConfig = clusterTableMapping.clusters[clusterName];
-                if (!clusterConfig || !clusterConfig.nginx) continue;
-
-                const tableName = clusterConfig.nginx;
-                const nginxLogPath = internalLogConfig.logFiles?.nginxLog || '/home/admin/logs/nginx.log';
-
-                // Build filter for sandbox execution logs
-                let filter = `@filename:${nginxLogPath} and ${sandboxId}`;
-
-                // Add URI filters if provided
-                if (uris && uris.length > 0) {
-                    const uriFilters = uris.map(uri => `request_uri:*${uri}*`).join(' or ');
-                    filter = `${filter} and (${uriFilters})`;
-                }
-
-                const logs = await queryLogs({
-                    tableName,
-                    startTime,
-                    endTime,
-                    filter,
-                    limit: 5000
-                });
-
-                if (logs && logs.length > 0) {
-                    foundCluster = clusterName;
-
-                    // Transform logs to request format
-                    for (const log of logs) {
-                        const request = this._transformLogToRequest(log);
-                        if (request) {
-                            requests.push(request);
-                        }
-                    }
-                }
-            }
-
-            // If we found data, no need to search further back
-            if (requests.length > 0) {
-                break;
-            }
-        }
-
-        return {
-            sandboxId,
-            requests,
-            metadata: {
-                cluster: foundCluster,
-                count: requests.length,
-                fetchedAt: new Date().toISOString()
-            }
-        };
-    }
-
-    /**
-     * Transform a log entry to a request object
-     * @param {Object} log - Log entry from Loghouse
-     * @returns {Object|null} Request object or null if invalid
-     */
-    _transformLogToRequest(log) {
-        if (!log) return null;
-
-        try {
-            const request = {
-                method: log.request_method || 'GET',
-                uri: log.request_uri || '',
-                timestamp: log['@timestamp'] || new Date().toISOString()
-            };
-
-            // Parse request body if present
-            if (log.request_body) {
-                try {
-                    request.requestBody = JSON.parse(log.request_body);
-                } catch {
-                    request.requestBody = log.request_body;
-                }
-            }
-
-            // Include relevant headers
-            if (log.request_headers) {
-                request.headers = log.request_headers;
-            }
-
-            return request;
-        } catch (error) {
-            logger.debug(`Failed to transform log: ${error.message}`);
-            return null;
-        }
-    }
-}
-
-module.exports = {
-    LoghouseDataSource,
-};

package/commands/sandbox/core/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
-};