rl-rockcli 0.0.2 → 0.0.4

package/commands/sandbox/core/replay/executor.js

@@ -1,634 +0,0 @@
-const fs = require('fs');
-const os = require('os');
-const path = require('path');
-const logger = require('../../../../utils/logger');
-const { RequestAction, RequestCategory } = require('./request');
-const { extractPidFromOutput } = require('./pid-mapping');
-
-/**
- * 回放执行器
- */
-class ReplayExecutor {
-  /**
-   * @param {Object} client - SandboxClient 实例
-   * @param {Object} options
-   * @param {string} options.timing - 时间控制: 'original' | 'fixed' | 'none'
-   * @param {number} options.interval - 固定间隔（秒）
-   * @param {boolean} options.quiet - 静默模式
-   * @param {string} options.logFile - 日志文件路径
-   * @param {boolean} options.verboseLog - 详细日志（记录 request/response）
-   */
-  constructor(client, options = {}) {
-    this.client = client;
-    this.options = {
-      timing: options.timing || 'none',
-      interval: options.interval || 5,
-      quiet: options.quiet || false,
-      logFile: options.logFile || 'replay.log',
-      verboseLog: options.verboseLog || false
-    };
-
-    this.currentSandboxId = null;
-    this.logStream = null;
-    this.criticalError = null;  // 关键错误（如 start_async 失败），会终止回放
-
-    // 从 client.config 提取 CLI 覆盖的 headers（优先级最高）
-    this.cliOverrideHeaders = {};
-    if (client.config) {
-      if (client.config.cluster) {
-        this.cliOverrideHeaders['x-cluster'] = client.config.cluster;
-      }
-      if (client.config.userId) {
-        this.cliOverrideHeaders['X-User-Id'] = client.config.userId;
-      }
-      if (client.config.experimentId) {
-        this.cliOverrideHeaders['X-Experiment-Id'] = client.config.experimentId;
-      }
-    }
-
-    // 执行结果统计
-    this.results = {
-      total: 0,
-      success: 0,
-      failed: 0,
-      skipped: 0
-    };
-  }
-
-  /**
-   * 合并 headers，CLI 参数优先
-   * @param {Object} reqHeaders - 请求中的 headers
-   * @returns {Object} - 合并后的 headers
-   */
-  mergeHeaders(reqHeaders) {
-    return {
-      ...reqHeaders,
-      ...this.cliOverrideHeaders
-    };
-  }
-
-  /**
-   * 初始化日志文件
-   */
-  initLogFile() {
-    this.logStream = fs.createWriteStream(this.options.logFile, { flags: 'a' });
-    this.logToFile('=== Replay Session Started ===');
-    this.logToFile(`Mode: ${this.options.timing}`);
-    this.logToFile(`Interval: ${this.options.interval}s`);
-  }
-
-  /**
-   * 关闭日志文件
-   */
-  closeLogFile() {
-    if (this.logStream) {
-      this.logToFile('=== Replay Session Ended ===');
-      this.logStream.end();
-    }
-  }
-
-  /**
-   * 执行回放计划
-   * @param {ReplayPlan} plan
-   * @returns {Object} 执行结果
-   */
-  async execute(plan) {
-    this.plan = plan;
-    this.results.total = plan.requests.length;
-    this.results.skipped = plan.skippedCount + plan.mergedCount;
-
-    this.initLogFile();
-
-    try {
-      for (let i = 0; i < plan.requests.length; i++) {
-        const req = plan.requests[i];
-        const progress = `[${i + 1}/${plan.requests.length}]`;
-
-        // 如果有关键错误，跳过后续请求
-        if (this.criticalError) {
-          this.results.skipped++;
-          this.logToFile(`${progress} SKIPPED: ${req.method} ${req.uri} (critical error: ${this.criticalError})`);
-          continue;
-        }
-
-        const startTime = Date.now();
-        try {
-          await this.executeRequest(req, progress);
-          this.results.success++;
-        } catch (error) {
-          this.results.failed++;
-          this.logError(progress, req, error);
-
-          // 检查是否是关键错误（start_async 失败）
-          if (req.uri.includes('start_async')) {
-            this.criticalError = error.message;
-            this.log(`   🛑 Critical error: sandbox creation failed, stopping replay`);
-            this.logToFile(`   CRITICAL: sandbox creation failed, remaining requests will be skipped`);
-          }
-        }
-        const duration = Date.now() - startTime;
-
-        // 记录到日志文件
-        this.logToFile(`${progress} ${req.method} ${req.uri} - Duration: ${duration}ms`);
-
-        // 时间控制
-        if (i < plan.requests.length - 1 && !this.criticalError) {
-          await this.waitBetweenRequests(req, plan.requests[i + 1]);
-        }
-      }
-    } finally {
-      this.closeLogFile();
-    }
-
-    return this.results;
-  }
-
-  /**
-   * 执行单个请求
-   * @param {ReplayRequest} req
-   * @param {string} progress
-   */
-  async executeRequest(req, progress) {
-    // 请求间分隔符
-    this.log('===');
-    this.logToFile('===');
-
-    // 替换 sandbox_id
-    this.replaceSandboxId(req);
-
-    switch (req.action) {
-      case RequestAction.EXECUTE:
-        return this.executeNormal(req, progress);
-
-      case RequestAction.EXECUTE_WITH_PROCESS_WAIT:
-        return this.executeWithProcessWait(req, progress);
-
-      default:
-        throw new Error(`Unknown action: ${req.action}`);
-    }
-  }
-
-  /**
-   * 普通执行
-   * @param {ReplayRequest} req
-   * @param {string} progress
-   */
-  async executeNormal(req, progress) {
-    this.log(`${progress} ${req.method} ${req.uri}`);
-
-    if (req.category === RequestCategory.UPLOAD) {
-      return this.executeUpload(req, progress);
-    }
-
-    // 合并 headers（CLI 参数优先）
-    const mergedHeaders = this.mergeHeaders(req.headers);
-
-    // 记录请求到日志文件（始终记录）
-    this.logToFile(`   [REQUEST] ${req.method} ${req.uri}`);
-    if (mergedHeaders && Object.keys(mergedHeaders).length > 0) {
-      this.logToFile(`   [REQUEST HEADERS] ${this.safeStringify(mergedHeaders)}`);
-    }
-    if (req.requestBody) {
-      this.logToFile(`   [REQUEST BODY] ${this.safeStringify(req.requestBody)}`);
-    }
-
-    const response = await this.client.makeRequest({
-      method: req.method,
-      uri: req.uri,
-      requestBody: req.requestBody,
-      headers: mergedHeaders
-    });
-
-    const status = response.status || (response.data?.status === 'Success' ? 200 : 500);
-
-    // 记录响应到日志文件（始终记录）
-    this.logToFile(`   [RESPONSE] Status: ${status}`);
-    if (response.headers) {
-      this.logToFile(`   [RESPONSE HEADERS] ${this.safeStringify(response.headers)}`);
-    }
-    if (response.data) {
-      this.logToFile(`   [RESPONSE DATA] ${this.safeStringify(response.data)}`);
-    }
-
-    // 检查状态码是否成功（必须先检查状态码，再处理特定逻辑）
-    if (status >= 400) {
-      const errorMsg = response.data?.message || response.data?.error || `HTTP ${status}`;
-      this.log(`   ❌ Status: ${status} - ${errorMsg}`);
-      throw new Error(`Request failed with status ${status}: ${errorMsg}`);
-    }
-
-    // 检查是否是 start_async 请求
-    if (req.uri.includes('start_async')) {
-      const sandboxId = response.data?.result?.sandbox_id;
-      if (sandboxId) {
-        this.currentSandboxId = sandboxId;
-        this.log(`   📝 sandbox_id: ${this.currentSandboxId}`);
-        this.logToFile(`   Extracted sandbox_id: ${this.currentSandboxId}`);
-
-        // 等待沙箱 alive
-        this.log(`   ⏳ Waiting for sandbox alive...`);
-        this.logToFile(`   Waiting for sandbox alive...`);
-        await this.waitForSandboxAlive();
-        this.log(`   ✅ Sandbox is alive!`);
-        this.logToFile(`   Sandbox is alive!`);
-      } else {
-        // start_async 成功但没有 sandbox_id，这是异常情况
-        this.log(`   ⚠️  Warning: start_async succeeded but no sandbox_id in response`);
-        this.logToFile(`   Warning: start_async succeeded but no sandbox_id in response`);
-        this.logToFile(`   Response: ${this.safeStringify(response.data)}`);
-      }
-    }
-
-    this.log(`   ✅ Status: ${status}`);
-    return response;
-  }
-
-  /**
-   * 执行上传请求
-   * @param {ReplayRequest} req
-   * @param {string} progress
-   */
-  async executeUpload(req, progress) {
-    const fileData = req.requestBody?.file;
-    if (!fileData) {
-      throw new Error('Upload request missing file data');
-    }
-
-    const filename = fileData.filename || 'unknown';
-    const content = fileData.content || '';
-    const targetPath = req.requestBody.target_path || `/tmp/${filename}`;
-
-    this.log(`   Uploading: ${filename} -> ${targetPath}`);
-
-    // 解码文件内容
-    let fileBuffer;
-    if (fileData.isBase64) {
-      fileBuffer = Buffer.from(content, 'base64');
-    } else {
-      fileBuffer = this.parseEscapedBinary(content);
-    }
-
-    // 写入临时文件
-    const tempDir = os.tmpdir();
-    const tempFilePath = path.join(tempDir, filename);
-    fs.writeFileSync(tempFilePath, fileBuffer);
-
-    try {
-      // 使用 SDK 上传
-      this.client._sandboxId = this.currentSandboxId;
-      const result = await this.client.uploadFile(tempFilePath, targetPath);
-
-      if (result.success) {
-        this.log(`   ✅ Upload success`);
-      } else {
-        throw new Error(result.message);
-      }
-
-      return result;
-    } finally {
-      // 清理临时文件
-      if (fs.existsSync(tempFilePath)) {
-        fs.unlinkSync(tempFilePath);
-      }
-    }
-  }
-
-  /**
-   * 执行 nohup 命令并等待进程结束
-   * @param {ReplayRequest} req
-   * @param {string} progress
-   */
-  async executeWithProcessWait(req, progress) {
-    const command = req.getCommand();
-    this.log(`${progress} ${req.method} ${req.uri}`);
-    this.log(`   Command: ${this.truncate(command, 70)}`);
-
-    // 合并 headers（CLI 参数优先）
-    const mergedHeaders = this.mergeHeaders(req.headers);
-
-    // 记录请求到日志文件（始终记录）
-    this.logToFile(`   [REQUEST] ${req.method} ${req.uri}`);
-    if (mergedHeaders && Object.keys(mergedHeaders).length > 0) {
-      this.logToFile(`   [REQUEST HEADERS] ${this.safeStringify(mergedHeaders)}`);
-    }
-    this.logToFile(`   [REQUEST BODY] ${this.safeStringify(req.requestBody)}`);
-
-    const response = await this.client.makeRequest({
-      method: req.method,
-      uri: req.uri,
-      requestBody: req.requestBody,
-      headers: mergedHeaders
-    });
-
-    const status = response.status || (response.data?.status === 'Success' ? 200 : 500);
-
-    // 记录响应到日志文件（始终记录）
-    this.logToFile(`   [RESPONSE] Status: ${status}`);
-    if (response.headers) {
-      this.logToFile(`   [RESPONSE HEADERS] ${this.safeStringify(response.headers)}`);
-    }
-    if (response.data) {
-      this.logToFile(`   [RESPONSE DATA] ${this.safeStringify(response.data)}`);
-    }
-
-    // 检查状态码是否成功
-    if (status >= 400) {
-      const errorMsg = response.data?.message || response.data?.error || `HTTP ${status}`;
-      this.log(`   ❌ Status: ${status} - ${errorMsg}`);
-      throw new Error(`Request failed with status ${status}: ${errorMsg}`);
-    }
-
-    this.log(`   ✅ Status: ${status}`);
-
-    // 提取 PID 并等待进程结束
-    const output = response.data?.result?.output || '';
-    const pid = extractPidFromOutput(output);
-
-    if (pid) {
-      this.log(`   📌 PID: ${pid}`);
-      this.logToFile(`   PID captured: ${pid}`);
-
-      // 等待进程结束
-      this.log(`   ⏳ Waiting for process ${pid} to complete...`);
-      this.logToFile(`   Waiting for process ${pid} to complete...`);
-      await this.waitForProcessComplete(pid, mergedHeaders);
-      this.log(`   ✅ Process ${pid} completed`);
-      this.logToFile(`   Process ${pid} completed`);
-    } else {
-      this.log(`   ⚠️  No PID found in output, skipping process wait`);
-      this.logToFile(`   No PID found in output, skipping process wait`);
-    }
-
-    return response;
-  }
-
-  /**
-   * 等待进程结束
-   * @param {string} pid - 进程 ID
-   * @param {Object} headers - 请求头
-   * @param {number} timeout - 超时时间（毫秒）
-   */
-  async waitForProcessComplete(pid, headers, timeout = 600000) {
-    const startTime = Date.now();
-    let pollCount = 0;
-
-    while (Date.now() - startTime < timeout) {
-      try {
-        pollCount++;
-        const elapsed = Math.round((Date.now() - startTime) / 1000);
-
-        // 使用 kill -0 检查进程是否存在
-        const response = await this.client.makeRequest({
-          method: 'POST',
-          uri: '/apis/envs/sandbox/v1/run_in_session',
-          requestBody: {
-            sandbox_id: this.currentSandboxId,
-            container_name: this.currentSandboxId,
-            session: 'agent',
-            action_type: 'bash',
-            command: `kill -0 ${pid}`,
-            check: 'silent'
-          },
-          headers
-        });
-
-        const exitCode = response.data?.result?.exit_code;
-        this.logToFile(`   [PROCESS_CHECK #${pollCount}] kill -0 ${pid} -> exit_code=${exitCode}, elapsed=${elapsed}s`);
-
-        // exit_code 非 0 表示进程已结束
-        if (exitCode !== 0) {
-          this.logToFile(`   [PROCESS_CHECK] Process ${pid} completed after ${pollCount} polls, ${elapsed}s`);
-          return;
-        }
-
-        // 等待 3 秒后重试
-        await this.sleep(3000);
-      } catch (error) {
-        // 请求失败也可能表示进程已结束
-        this.logToFile(`   [PROCESS_CHECK] Error checking process: ${error.message}`);
-        return;
-      }
-    }
-
-    // 超时
-    const elapsed = Math.round((Date.now() - startTime) / 1000);
-    this.log(`   ⚠️  Process wait timeout after ${elapsed}s`);
-    this.logToFile(`   Process wait timeout after ${elapsed}s, ${pollCount} polls`);
-  }
-
-  /**
-   * 替换请求中的 sandbox_id
-   * @param {ReplayRequest} req
-   */
-  replaceSandboxId(req) {
-    if (this.currentSandboxId) {
-      if (req.requestBody?.sandbox_id) {
-        req.requestBody.sandbox_id = this.currentSandboxId;
-      }
-      if (req.requestBody?.container_name) {
-        req.requestBody.container_name = this.currentSandboxId;
-      }
-      if (req.uri && req.uri.includes('sandbox_id=')) {
-        req.uri = req.uri.replace(/sandbox_id=[^&]+/, `sandbox_id=${this.currentSandboxId}`);
-      }
-    }
-  }
-
-  /**
-   * 等待沙箱 alive
-   * @param {number} timeout - 超时时间（毫秒）
-   */
-  async waitForSandboxAlive(timeout = 120000) {
-    const startTime = Date.now();
-    this.client._sandboxId = this.currentSandboxId;
-    let pollCount = 0;
-    let lastError = null;
-    let lastStatus = null;
-
-    while (Date.now() - startTime < timeout) {
-      try {
-        pollCount++;
-        const status = await this.client.getStatus();
-        lastStatus = status;
-        const elapsed = Math.round((Date.now() - startTime) / 1000);
-
-        // 记录每次轮询到日志文件（始终记录）
-        this.logToFile(`   [GET_STATUS #${pollCount}] is_alive=${status.is_alive}, elapsed=${elapsed}s`);
-        if (status.status) {
-          this.logToFile(`   [GET_STATUS #${pollCount}] stages: ${this.safeStringify(status.status)}`);
-        }
-
-        if (status.is_alive) {
-          this.logToFile(`   [GET_STATUS] Sandbox alive after ${pollCount} polls, ${elapsed}s`);
-          return;
-        }
-
-        // 检查失败状态
-        if (status.status) {
-          for (const [stage, details] of Object.entries(status.status)) {
-            if (details.status === 'failed' || details.status === 'timeout') {
-              // 忽略 ray_schedule 失败
-              if (stage === 'ray_schedule') continue;
-              this.logToFile(`   [GET_STATUS] Sandbox failed at ${stage}: ${details.message || 'Unknown error'}`);
-              throw new Error(`Sandbox failed at ${stage}: ${details.message || 'Unknown error'}`);
-            }
-          }
-        }
-
-        await this.sleep(3000);
-      } catch (error) {
-        if (error.message.includes('Sandbox failed')) {
-          throw error;
-        }
-        // 记录错误但保存以便超时时使用
-        lastError = error;
-        this.logToFile(`   [GET_STATUS] Error: ${error.message}`);
-        // 如果是 HTTP 错误，附加响应信息
-        if (error.response?.data) {
-          this.logToFile(`   Response: ${this.safeStringify(error.response.data)}`);
-        }
-        logger.warn(`Failed to check sandbox status: ${error.message}`);
-        throw error;
-      }
-    }
-
-    // 超时时提供更详细的错误信息
-    const elapsed = Math.round((Date.now() - startTime) / 1000);
-    let errorMessage = `Sandbox did not become alive within ${timeout}ms (${elapsed}s, ${pollCount} polls)`;
-
-    if (lastError) {
-      errorMessage += `. Last error: ${lastError.message}`;
-    } else if (lastStatus?.status) {
-      // 附加最后的 stage 信息
-      const stageInfo = Object.entries(lastStatus.status)
-        .map(([k, v]) => `${k}=${v.status}`)
-        .join(', ');
-      errorMessage += `. Last stages: ${stageInfo}`;
-    }
-
-    throw new Error(errorMessage);
-  }
-
-  /**
-   * 请求间等待
-   * @param {ReplayRequest} currentReq
-   * @param {ReplayRequest} nextReq
-   */
-  async waitBetweenRequests(currentReq, nextReq) {
-    // start_async 后不需要额外等待（已经等待 alive）
-    if (currentReq.uri?.includes('start_async')) {
-      return;
-    }
-
-    switch (this.options.timing) {
-      case 'original':
-        if (currentReq.responseTime && nextReq.responseTime) {
-          const gap = nextReq.responseTime - currentReq.responseTime;
-          if (gap > 0 && gap < 60000) {
-            if (!this.options.quiet) {
-              this.log(`   ⏸️  Waiting ${(gap / 1000).toFixed(1)}s (original timing)...`);
-            }
-            await this.sleep(gap);
-          }
-        }
-        break;
-
-      case 'fixed':
-        if (this.options.interval > 0) {
-          if (!this.options.quiet) {
-            this.log(`   ⏸️  Waiting ${this.options.interval}s...`);
-          }
-          await this.sleep(this.options.interval * 1000);
-        }
-        break;
-
-      case 'none':
-      default:
-        // 不等待
-        break;
-    }
-  }
-
-  // 辅助方法
-  log(message) {
-    if (!this.options.quiet) {
-      console.log(message);
-    }
-  }
-
-  logToFile(message) {
-    if (this.logStream) {
-      const timestamp = new Date().toISOString();
-      this.logStream.write(`[${timestamp}] ${message}\n`);
-    }
-  }
-
-  logError(progress, req, error) {
-    this.log(`${progress} ${req.method} ${req.uri}`);
-    this.log(`   ❌ Failed: ${error.message}`);
-    this.logToFile(`${progress} FAILED: ${error.message}`);
-
-    // 记录更多错误细节
-    if (error.response?.data) {
-      this.logToFile(`   Response: ${JSON.stringify(error.response.data)}`);
-    }
-  }
-
-  truncate(str, maxLen) {
-    if (!str) return '';
-    if (str.length <= maxLen) return str;
-    return str.substring(0, maxLen - 3) + '...';
-  }
-
-  /**
-   * 安全的 JSON 序列化（处理大对象和循环引用）
-   * @param {*} obj
-   * @param {number} maxLen - 最大长度
-   * @returns {string}
-   */
-  safeStringify(obj, maxLen = 2000) {
-    try {
-      const str = JSON.stringify(obj);
-      if (str.length > maxLen) {
-        return str.substring(0, maxLen) + '... (truncated)';
-      }
-      return str;
-    } catch (error) {
-      return `[Stringify Error: ${error.message}]`;
-    }
-  }
-
-  sleep(ms) {
-    return new Promise(resolve => setTimeout(resolve, ms));
-  }
-
-  parseEscapedBinary(str) {
-    const buffer = [];
-    let i = 0;
-    while (i < str.length) {
-      if (str[i] === '\\' && i + 1 < str.length) {
-        if (str[i + 1] === 'x' && i + 3 < str.length) {
-          const hexCode = str.substr(i + 2, 2);
-          const byteValue = parseInt(hexCode, 16);
-          buffer.push(byteValue);
-          i += 4;
-        } else {
-          const char = str[i + 1];
-          switch (char) {
-            case 'n': buffer.push(0x0A); i += 2; break;
-            case 'r': buffer.push(0x0D); i += 2; break;
-            case 't': buffer.push(0x09); i += 2; break;
-            case '\\': buffer.push(0x5C); i += 2; break;
-            default: buffer.push(char.charCodeAt(0)); i += 2; break;
-          }
-        }
-      } else {
-        buffer.push(str.charCodeAt(i));
-        i++;
-      }
-    }
-    return Buffer.from(buffer);
-  }
-}
-
-module.exports = { ReplayExecutor };