rl-rockcli 0.0.6 → 0.0.8

package/sdks/sandbox/core/client.js

@@ -1,845 +0,0 @@
-const axios = require('axios');
-const { SandboxConfig } = require('./config');
-const logger = require('../../../utils/logger');
-const { httpLogger } = require('../httpLogger');
-
-/**
- * Sandbox Client for managing sandbox environments
- */
-class SandboxClient {
-  constructor(config, options = {}) {
-    if (config instanceof SandboxConfig) {
-      this.config = config;
-    } else {
-      this.config = new SandboxConfig(config);
-    }
-    this.config.validate({ requireImage: options.requireImage !== false });
-
-    this._sandboxId = null;
-    this._hostName = null;
-    this._hostIp = null;
-    this._url = `${this.config.baseUrl}/apis/envs/sandbox/v1`;
-    this._onLog = options.onLog || null;
-
-    // Allow injection of custom headers builder for internal/external environments
-    // Core version only builds basic headers; internal version can inject additional headers
-    this._buildHeadersFn = options.buildHeaders || null;
-
-    // Create axios instance with interceptors for HTTP logging
-    this._axios = axios.create();
-    this._setupInterceptors();
-  }
-
-  /**
-   * Log a message, either through callback or directly
-   * @private
-   * @param {string} level - Log level ('info', 'warn', 'debug')
-   * @param {string} message - Log message
-   */
-  _log(level, message) {
-    if (this._onLog) {
-      this._onLog(level, message);
-    } else {
-      logger[level](message);
-    }
-  }
-
-  /**
-   * Setup axios interceptors for HTTP logging
-   */
-  _setupInterceptors() {
-    // Request interceptor
-    this._axios.interceptors.request.use((config) => {
-      config._startTime = Date.now();
-      httpLogger.logRequest(
-        config.method?.toUpperCase() || 'GET',
-        config.url,
-        config.data
-      );
-      return config;
-    });
-
-    // Response interceptor
-    this._axios.interceptors.response.use(
-      (response) => {
-        const duration = Date.now() - (response.config._startTime || Date.now());
-        // Extract trace ID from response headers
-        const traceId = this._extractTraceId(response.headers);
-        httpLogger.logResponse(
-          response.config.method?.toUpperCase() || 'GET',
-          response.config.url,
-          response.status,
-          duration,
-          response.data,
-          traceId
-        );
-        return response;
-      },
-      (error) => {
-        const duration = Date.now() - (error.config?._startTime || Date.now());
-        // Try to extract trace ID from error response
-        const traceId = error.response ? this._extractTraceId(error.response.headers) : null;
-        httpLogger.logError(
-          error.config?.method?.toUpperCase() || 'GET',
-          error.config?.url || 'unknown',
-          error,
-          duration,
-          traceId
-        );
-        return Promise.reject(error);
-      }
-    );
-  }
-
-  /**
-   * Extract trace ID from response headers
-   * Checks common trace ID header names
-   */
-  _extractTraceId(headers) {
-    if (!headers) return null;
-
-    // Common trace ID header names (case-insensitive in axios)
-    const traceIdHeaders = [
-      'x-trace-id',
-      'x-request-id',
-      'traceid',
-      'trace-id',
-      'request-id',
-      'x-b3-traceid',
-    ];
-
-    for (const headerName of traceIdHeaders) {
-      const value = headers[headerName];
-      if (value) return value;
-    }
-
-    return null;
-  }
-
-  get sandboxId() {
-    return this._sandboxId;
-  }
-
-  get hostName() {
-    return this._hostName;
-  }
-
-  get hostIp() {
-    return this._hostIp;
-  }
-
-  _buildHeaders() {
-    // Core headers - common to all environments
-    const headers = {
-      'Content-Type': 'application/json',
-    };
-
-    // XRL-Authorization is a common authentication mechanism
-    if (this.config.xrlAuthorization) {
-      headers['XRL-Authorization'] = `Bearer ${this.config.xrlAuthorization}`;
-    }
-
-    // Allow extra headers to be passed in config
-    if (this.config.extraHeaders) {
-      Object.assign(headers, this.config.extraHeaders);
-    }
-
-    // Inject additional headers from custom builder (e.g., internal headers)
-    if (this._buildHeadersFn) {
-      const additionalHeaders = this._buildHeadersFn(this.config);
-      Object.assign(headers, additionalHeaders);
-    }
-
-    return headers;
-  }
-
-  /**
-   * Start a new sandbox instance
-   * @returns {Promise<Object>} Sandbox instance info
-   */
-  async start() {
-    const url = `${this._url}/start_async`;
-    const headers = this._buildHeaders();
-    const data = {
-      image: this.config.image,
-      auto_clear_time: Math.floor(this.config.autoClearSeconds / 60),
-      auto_clear_time_minutes: Math.floor(this.config.autoClearSeconds / 60),
-      startup_timeout: this.config.startupTimeout,
-      memory: this.config.memory,
-      cpus: this.config.cpus,
-    };
-
-    logger.debug(`[Sandbox SDK] POST ${url}`);
-    logger.debug(`[Sandbox SDK] Request headers: ${JSON.stringify(headers)}`);
-    logger.debug(`[Sandbox SDK] Request body: ${JSON.stringify(data)}`);
-
-    const response = await this._axios.post(url, data, { headers });
-    logger.debug(`[Sandbox SDK] Response: ${JSON.stringify(response.data)}`);
-
-    if (response.data.status !== 'Success') {
-      const error = response.data.result || response.data;
-      throw new Error(`Failed to start sandbox: ${JSON.stringify(error)}`);
-    }
-
-    const result = response.data.result;
-    this._sandboxId = result.sandbox_id;
-    this._hostName = result.host_name;
-    this._hostIp = result.host_ip;
-
-    let isAlive = false;
-    if (this.config.waitForAlive) {
-      // Wait for sandbox to be alive
-      await this._waitForAlive();
-      isAlive = true;
-    }
-
-    return {
-      sandboxId: this._sandboxId,
-      hostName: this._hostName,
-      hostIp: this._hostIp,
-      isAlive: isAlive,
-    };
-  }
-
-  async _waitForAlive() {
-    const startTime = Date.now();
-    const timeout = this.config.startupTimeout * 1000;
-    let lastStatus = null;
-    let lastLogTime = 0;
-    const loadingChars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    let loadingIndex = 0;
-
-    this._log('info', 'Waiting for sandbox to be ready...');
-
-    while (Date.now() - startTime < timeout) {
-      const status = await this.getStatus();
-
-      if (status.is_alive) {
-        this._log('info', `Sandbox is ready (ID: ${this._sandboxId})`);
-        return;
-      }
-
-      // Show progress for status changes
-      if (status.status && JSON.stringify(status.status) !== JSON.stringify(lastStatus)) {
-        lastStatus = status.status;
-        const stageInfo = Object.entries(status.status)
-          .map(([stage, details]) => {
-            const icon = details.status === 'success' ? '✓' :
-              details.status === 'failed' ? '✗' :
-                details.status === 'running' ? '⟳' : '○';
-            return `${stage}: ${icon}`;
-          })
-          .join(', ');
-        this._log('info', `Sandbox startup progress: ${stageInfo}`);
-      }
-
-      // Show loading animation every 3 seconds if no status change
-      const now = Date.now();
-      if (now - lastLogTime > 3000) {
-        loadingIndex = (loadingIndex + 1) % loadingChars.length;
-        const elapsed = Math.floor((now - startTime) / 1000);
-        this._log('info', `${loadingChars[loadingIndex]} Starting sandbox... (${elapsed}s elapsed)`);
-        lastLogTime = now;
-      }
-
-      // Check for failures
-      if (status.status) {
-        for (const [stage, details] of Object.entries(status.status)) {
-          if (details.status === 'failed' || details.status === 'timeout') {
-            // Ignore ray_schedule failure during wait for alive
-            if (stage === 'ray_schedule') {
-              this._log('debug', `Ignoring ray_schedule failure during wait for alive: ${details.message || 'Unknown error'}`);
-              continue;
-            }
-            throw new Error(`Sandbox failed at ${stage}: ${details.message || 'Unknown error'}`);
-          }
-        }
-      }
-
-      await new Promise(resolve => setTimeout(resolve, 3000));
-    }
-
-    throw new Error(`Sandbox did not become alive within ${this.config.startupTimeout}s`);
-  }
-
-  /**
-   * Get sandbox status
-   * @returns {Promise<Object>} Sandbox status
-   */
-  async getStatus() {
-    const url = `${this._url}/get_status?sandbox_id=${this._sandboxId}`;
-    const headers = this._buildHeaders();
-
-    logger.debug(`[Sandbox SDK] GET ${url}`);
-    logger.debug(`[Sandbox SDK] Request headers: ${JSON.stringify(headers)}`);
-
-    const response = await this._axios.get(url, { headers });
-    logger.debug(`[Sandbox SDK] Response headers: ${JSON.stringify(response.headers)}`);
-    logger.debug(`[Sandbox SDK] Response: ${JSON.stringify(response.data)}`);
-
-    if (response.data.status !== 'Success') {
-      throw new Error(`Failed to get status: ${JSON.stringify(response.data)}`);
-    }
-
-    const result = response.data.result;
-    // 从响应头中提取 cluster 和其他有用信息
-    result.cluster = response.headers['x-rock-gateway-target-cluster'] || 'N/A';
-    result.request_id = response.headers['x-request-id'] || response.headers['request-id'] || 'N/A';
-    result.eagleeye_traceid = response.headers['eagleeye-traceid'] || 'N/A';
-
-    return result;
-  }
-
-  /**
-   * Check if sandbox is alive
-   * @returns {Promise<Object>} IsAlive response
-   */
-  async isAlive() {
-    try {
-      const status = await this.getStatus();
-      return {
-        isAlive: status.is_alive,
-        message: status.host_name || '',
-      };
-    } catch (error) {
-      logger.warn(`Failed to check isAlive: ${error.message}`);
-      throw new Error(`Failed to check isAlive: ${error.message}`);
-    }
-  }
-
-  /**
-   * Execute a command in the sandbox
-   * @param {string|Array} command - Command to execute
-   * @returns {Promise<Object>} Command response
-   */
-  async execute(command) {
-    const url = `${this._url}/execute`;
-    const headers = this._buildHeaders();
-
-    let commandArray;
-    if (Array.isArray(command)) {
-      // Array command: use as-is
-      commandArray = command;
-    } else {
-      // String command: wrap with sh -c to support shell operators (&&, ||, ;, |, etc.)
-      commandArray = ['sh', '-c', command];
-    }
-
-    const data = {
-      command: commandArray,
-      sandbox_id: this._sandboxId,
-    };
-
-    logger.debug(`[Sandbox SDK] POST ${url}`);
-    logger.debug(`[Sandbox SDK] Request body: ${JSON.stringify(data)}`);
-
-    const response = await this._axios.post(url, data, { headers });
-    logger.debug(`[Sandbox SDK] Response headers: ${JSON.stringify(response.headers)}`);
-    logger.debug(`[Sandbox SDK] Response: ${JSON.stringify(response.data)}`);
-
-    if (response.data.status !== 'Success') {
-      throw new Error(`Failed to execute command: ${JSON.stringify(response.data)}`);
-    }
-
-    return response.data.result;
-  }
-
-  /**
-   * Stop the sandbox
-   */
-  async stop() {
-    if (!this._sandboxId) {
-      logger.warn('No sandbox ID to stop');
-      return;
-    }
-
-    try {
-      const url = `${this._url}/stop`;
-      const headers = this._buildHeaders();
-      const data = {
-        sandbox_id: this._sandboxId,
-      };
-
-      logger.debug(`[Sandbox SDK] POST ${url}`);
-      logger.debug(`[Sandbox SDK] Request headers: ${JSON.stringify(headers)}`);
-      logger.debug(`[Sandbox SDK] Request body: ${JSON.stringify(data)}`);
-
-      const response = await this._axios.post(url, data, { headers });
-      logger.debug(`[Sandbox SDK] Response headers: ${JSON.stringify(response.headers)}`);
-      logger.debug(`[Sandbox SDK] Response: ${JSON.stringify(response.data)}`);
-      logger.info(`Sandbox ${this._sandboxId} stopped successfully`);
-    } catch (error) {
-      logger.warn(`Failed to stop sandbox: ${error.message}`);
-    }
-  }
-
-  /**
-   * Create a bash session
-   * @param {Object} options - Session options
-   * @returns {Promise<Object>} Create session response
-   */
-  async createSession(options = {}) {
-    const url = `${this._url}/create_session`;
-    const headers = this._buildHeaders();
-
-    const data = {
-      sandbox_id: this._sandboxId,
-      session: options.session || 'default',
-      session_type: options.sessionType || 'bash',
-      startup_source: options.startupSource || [],
-      env_enable: options.envEnable || false,
-    };
-
-    if (options.env) {
-      data.env = options.env;
-    }
-
-    if (options.startupTimeout !== undefined) {
-      data.startup_timeout = options.startupTimeout;
-    }
-
-    logger.debug(`[Sandbox SDK] POST ${url}`);
-    logger.debug(`[Sandbox SDK] Request headers: ${JSON.stringify(headers)}`);
-    logger.debug(`[Sandbox SDK] Request body: ${JSON.stringify(data)}`);
-
-    const response = await this._axios.post(url, data, { headers });
-    logger.debug(`[Sandbox SDK] Response headers: ${JSON.stringify(response.headers)}`);
-    logger.debug(`[Sandbox SDK] Response: ${JSON.stringify(response.data)}`);
-
-    if (response.data.status !== 'Success') {
-      throw new Error(`Failed to create session: ${JSON.stringify(response.data)}`);
-    }
-
-    return response.data.result;
-  }
-
-  /**
-   * Run a command in a session
-   * @param {Object} action - Action to execute
-   * @returns {Promise<Object>} Observation result
-   */
-  async runInSession(action) {
-    const url = `${this._url}/run_in_session`;
-    const headers = this._buildHeaders();
-
-    const data = {
-      sandbox_id: this._sandboxId,
-      command: action.command,
-      session: action.session || 'default',
-      timeout: action.timeout || null,
-      is_interactive_command: action.isInteractiveCommand || false,
-      check: action.check || 'raise',
-    };
-
-    if (action.expect) {
-      data.expect = action.expect;
-    }
-
-    logger.debug(`[Sandbox SDK] POST ${url}`);
-    logger.debug(`[Sandbox SDK] Request headers: ${JSON.stringify(headers)}`);
-    logger.debug(`[Sandbox SDK] Request body: ${JSON.stringify(data)}`);
-
-    const axiosConfig = {
-      headers,
-    };
-
-    // Set axios timeout if provided (in milliseconds)
-    // axiosTimeout takes precedence over timeout for HTTP layer
-    if (action.axiosTimeout) {
-      axiosConfig.timeout = action.axiosTimeout;
-    } else if (action.timeout) {
-      // If only backend timeout is set, also set axios timeout (timeout is in seconds)
-      axiosConfig.timeout = action.timeout * 1000;
-    }
-
-    // Pass AbortSignal for cancellation support
-    if (action.signal) {
-      axiosConfig.signal = action.signal;
-    }
-
-    const response = await this._axios.post(url, data, axiosConfig);
-    logger.debug(`[Sandbox SDK] Response headers: ${JSON.stringify(response.headers)}`);
-    logger.debug(`[Sandbox SDK] Response: ${JSON.stringify(response.data)}`);
-
-    if (response.data.status !== 'Success') {
-      throw new Error(`Failed to run in session: ${JSON.stringify(response.data)}`);
-    }
-
-    return response.data.result;
-  }
-
-  /**
-   * Write content to a file in the sandbox
-   * @param {string} content - Content to write
-   * @param {string} path - Target file path
-   * @returns {Promise<Object>} Write file response
-   */
-  async writeFile(content, path) {
-    const url = `${this._url}/write_file`;
-    const headers = this._buildHeaders();
-
-    const data = {
-      content,
-      path,
-      sandbox_id: this._sandboxId,
-    };
-
-    logger.debug(`[Sandbox SDK] POST ${url}`);
-    logger.debug(`[Sandbox SDK] Request headers: ${JSON.stringify(headers)}`);
-    logger.debug(`[Sandbox SDK] Request body: ${JSON.stringify({ ...data, content: content.length > 100 ? content.substring(0, 100) + '...' : content })}`);
-
-    const response = await this._axios.post(url, data, { headers });
-    logger.debug(`[Sandbox SDK] Response: ${JSON.stringify(response.data)}`);
-
-    if (response.data.status !== 'Success') {
-      return {
-        success: false,
-        message: `Failed to write file ${path}: ${JSON.stringify(response.data)}`,
-      };
-    }
-
-    return {
-      success: true,
-      message: `Successfully wrote content to file ${path}`,
-    };
-  }
-
-  /**
-   * Read a file from the sandbox
-   * @param {string} filePath - File path to read
-   * @param {number} startLine - Start line (1-indexed)
-   * @param {number} endLine - End line (1-indexed)
-   * @returns {Promise<Object>} Read file response
-   */
-  async readFile(filePath, startLine, endLine) {
-    if (startLine < 1 || endLine < startLine) {
-      throw new Error(`Invalid line range: startLine=${startLine}, endLine=${endLine}`);
-    }
-
-    if (endLine - startLine > 1000) {
-      throw new Error(`Line range too large: ${endLine - startLine} lines (max 1000)`);
-    }
-
-    const command = `sed -n ${startLine},${endLine}p ${filePath}`;
-    const result = await this.execute(command);
-
-    if (result.exit_code !== 0) {
-      throw new Error(`Failed to read file ${filePath}: ${result.stderr}`);
-    }
-
-    return {
-      content: result.stdout,
-    };
-  }
-
-  /**
-   * Upload a file to the sandbox
-   * @param {string} localPath - Local file path
-   * @param {string} targetPath - Target path in sandbox
-   * @returns {Promise<Object>} Upload response
-   */
-  async uploadFile(localPath, targetPath) {
-    const fs = require('fs');
-    const path = require('path');
-
-    try {
-      if (!fs.existsSync(localPath)) {
-        return {
-          success: false,
-          message: `File not found: ${localPath}`,
-        };
-      }
-
-      const url = `${this._url}/upload`;
-      const headers = this._buildHeaders();
-      delete headers['Content-Type'];
-
-      // Use native FormData for bun compatibility
-      const form = new FormData();
-      const fileBuffer = fs.readFileSync(localPath);
-      const blob = new Blob([fileBuffer], { type: 'application/octet-stream' });
-
-      form.append('file', blob, path.basename(localPath));
-      form.append('target_path', targetPath);
-      form.append('sandbox_id', this._sandboxId);
-      form.append('container_name', this._sandboxId);
-
-      logger.debug(`[Sandbox SDK] POST ${url}`);
-      logger.debug(`[Sandbox SDK] Request body: target_path=${targetPath}, sandbox_id=${this._sandboxId}, container_name=${this._sandboxId}, file=${path.basename(localPath)}`);
-      logger.debug(`[Sandbox SDK] Upload file: ${localPath} -> ${targetPath}`);
-
-      const response = await fetch(url, {
-        method: 'POST',
-        headers,
-        body: form,
-      });
-
-      const data = await response.json();
-      logger.debug(`[Sandbox SDK] Response: ${JSON.stringify(data)}`);
-
-      if (data.status !== 'Success') {
-        return {
-          success: false,
-          message: `Failed to upload file: ${JSON.stringify(data)}`,
-        };
-      }
-
-      return {
-        success: true,
-        message: `Successfully uploaded ${path.basename(localPath)} to ${targetPath}`,
-      };
-    } catch (error) {
-      logger.debug(`[Sandbox SDK] Upload error: ${error}`);
-      const errorMessage = error?.message || (typeof error === 'string' ? error : 'Unknown error');
-      return {
-        success: false,
-        message: `Upload failed: ${errorMessage}`,
-      };
-    }
-  }
-
-  /**
-   * Download a file from the sandbox
-   * @param {string} filePath - File path in sandbox
-   * @returns {Promise<Object>} Download response
-   */
-  async downloadFile(filePath) {
-    const url = `${this._url}/read_file`;
-    const headers = this._buildHeaders();
-
-    const data = {
-      path: filePath,
-      sandbox_id: this._sandboxId,
-    };
-
-    logger.debug(`[Sandbox SDK] POST ${url}`);
-    logger.debug(`[Sandbox SDK] Request body: ${JSON.stringify(data)}`);
-
-    const response = await this._axios.post(url, data, { headers });
-    logger.debug(`[Sandbox SDK] Response: ${JSON.stringify(response.data)}`);
-
-    if (response.data.status !== 'Success') {
-      throw new Error(`Failed to download file: ${JSON.stringify(response.data)}`);
-    }
-
-    return response.data.result;
-  }
-
-  /**
-   * Make a generic HTTP request to the sandbox API
-   * @param {Object} request - Request object
-   * @param {string} request.method - HTTP method (GET, POST, PUT, DELETE, etc.)
-   * @param {string} request.uri - Request URI path
-   * @param {Object} request.requestBody - Request body data
-   * @param {Object} request.headers - Request headers
-   * @returns {Promise<Object>} Response data
-   */
-  async makeRequest(request) {
-    const { method, uri, requestBody, headers } = request;
-    const url = `${this.config.baseUrl}${uri}`;
-    const requestHeaders = this._buildHeaders();
-
-    // Merge custom headers
-    if (headers) {
-      Object.assign(requestHeaders, headers);
-    }
-
-    logger.debug(`[Sandbox SDK] ${method} ${url}`);
-    logger.debug(`[Sandbox SDK] Request headers: ${JSON.stringify(requestHeaders)}`);
-    if (requestBody) {
-      logger.debug(`[Sandbox SDK] Request body: ${JSON.stringify(requestBody)}`);
-    }
-
-    const axiosConfig = {
-      method: method.toLowerCase(),
-      url,
-      headers: requestHeaders,
-    };
-
-    if (requestBody) {
-      axiosConfig.data = requestBody;
-    }
-
-    const response = await axios(axiosConfig);
-    logger.debug(`[Sandbox SDK] Response: ${JSON.stringify(response.data)}`);
-
-    return {
-      data: response.data,
-      headers: response.headers,
-      status: response.status
-    };
-  }
-
-  /**
-   * Close a session
-   * @param {string} session - Session name (default: 'default')
-   * @returns {Promise<Object>} Close session response
-   */
-  async closeSession(session = 'default') {
-    const url = `${this._url}/close_session`;
-    const headers = this._buildHeaders();
-
-    const data = {
-      sandbox_id: this._sandboxId,
-      session: session,
-    };
-
-    logger.debug(`[Sandbox SDK] POST ${url}`);
-    logger.debug(`[Sandbox SDK] Request headers: ${JSON.stringify(headers)}`);
-    logger.debug(`[Sandbox SDK] Request body: ${JSON.stringify(data)}`);
-
-    const response = await this._axios.post(url, data, { headers });
-    logger.debug(`[Sandbox SDK] Response headers: ${JSON.stringify(response.headers)}`);
-    logger.debug(`[Sandbox SDK] Response: ${JSON.stringify(response.data)}`);
-
-    if (response.data.status !== 'Success') {
-      throw new Error(`Failed to close session: ${JSON.stringify(response.data)}`);
-    }
-
-    return response.data.result;
-  }
-
-  /**
-   * Run a command asynchronously in a session using nohup + kill -0 polling
-   * @param {Object} action - Action configuration
-   * @param {string} action.session - Session name
-   * @param {string} action.command - Command to execute
-   * @param {number} [action.timeout] - Total timeout in milliseconds
-   * @param {number} [action.pollInterval] - Polling interval in milliseconds (default: 5000)
-   * @param {boolean} [action.killOnTimeout] - Whether to kill process on timeout (default: false)
-   * @param {boolean} [action.cleanupLog] - Whether to cleanup log file (default: false)
-   * @returns {Promise<Object>} Result with output, exit_code, and optional timeout/warning
-   */
-  async runInSessionAsync(action) {
-    const session = action.session || 'default';
-    const timeoutMs = action.timeout || 3600000; // Default 1 hour
-    const pollInterval = action.pollInterval || 5000;
-    const killOnTimeout = action.killOnTimeout || false;
-    const cleanupLog = action.cleanupLog || false;
-
-    // Generate unique log file
-    const logFile = `/tmp/arun-${Date.now()}.log`;
-
-    // Build nohup command with PID marker
-    const nohupCommand = `nohup ${action.command} < /dev/null > ${logFile} 2>&1 & echo PIDSTART$!PIDEND;disown`;
-
-    logger.debug(`[Sandbox SDK] Starting async command: ${action.command}`);
-
-    // 1. Execute nohup command
-    const startResult = await this.runInSession({
-      session,
-      command: nohupCommand
-    });
-
-    // 2. Extract PID
-    const pidMatch = startResult.output.match(/PIDSTART(\d+)PIDEND/);
-    if (!pidMatch) {
-      throw new Error('Failed to extract PID from nohup output');
-    }
-    const pid = pidMatch[1];
-    logger.debug(`[Sandbox SDK] Started process with PID: ${pid}`);
-
-    // 3. Poll for process completion
-    const startTime = Date.now();
-    let pollCount = 0;
-    const maxPolls = Math.ceil(timeoutMs / pollInterval);
-
-    while (Date.now() - startTime < timeoutMs) {
-      pollCount++;
-      logger.debug(`[Sandbox SDK] [${pollCount}/${maxPolls}] Checking process ${pid}...`);
-      console.log(`[${pollCount}/${maxPolls}] Waiting for process ${pid}...`);
-
-      // Check if process is still running (kill -0)
-      const checkResult = await this.runInSession({
-        session,
-        command: `kill -0 ${pid}`,
-        check: 'silent'  // Don't throw on non-zero exit
-      });
-
-      if (checkResult.exit_code !== 0) {
-        // Process has finished
-        logger.debug(`[Sandbox SDK] Process ${pid} finished`);
-        console.log(`Process ${pid} finished`);
-        break;
-      }
-
-      // Wait before next poll
-      await new Promise(resolve => setTimeout(resolve, pollInterval));
-    }
-
-    // 4. Check for timeout
-    const elapsed = Date.now() - startTime;
-    let timedOut = false;
-
-    if (elapsed >= timeoutMs) {
-      timedOut = true;
-      logger.warn(`[Sandbox SDK] Process ${pid} timed out after ${elapsed}ms`);
-      console.log(`⚠️ Process ${pid} timed out after ${elapsed}ms`);
-
-      if (killOnTimeout) {
-        logger.debug(`[Sandbox SDK] Killing process ${pid}`);
-        await this.runInSession({
-          session,
-          command: `kill ${pid}`,
-          check: 'silent'
-        });
-        // Wait a moment for process to terminate
-        await new Promise(resolve => setTimeout(resolve, 100));
-      }
-    }
-
-    // 5. Read output from log file
-    const outputResult = await this.runInSession({
-      session,
-      command: `cat ${logFile} 2>/dev/null; echo "EXITCODE:$?"`
-    });
-
-    // Parse exit code from output
-    let output = outputResult.output || '';
-    let exitCode = 0;
-
-    // If process was killed due to timeout, exit code is 137 (SIGKILL)
-    if (timedOut && killOnTimeout) {
-      exitCode = 137;
-    } else {
-      const exitCodeMatch = output.match(/EXITCODE:(\d+)/);
-      if (exitCodeMatch) {
-        exitCode = parseInt(exitCodeMatch[1], 10);
-      }
-    }
-
-    output = output.replace(/EXITCODE:\d+\n?$/, '');
-
-    // 6. Cleanup log file if requested
-    if (cleanupLog) {
-      await this.runInSession({
-        session,
-        command: `rm -f ${logFile}`,
-        check: 'silent'
-      });
-      logger.debug(`[Sandbox SDK] Cleaned up log file: ${logFile}`);
-    }
-
-    // Build result
-    const result = {
-      output: output.trim(),
-      exit_code: exitCode
-    };
-
-    if (timedOut) {
-      result.timeout = true;
-      result.warning = `Process ${pid} timed out after ${timeoutMs}ms`;
-    }
-
-    return result;
-  }
-
-  /**
-   * Close the sandbox
-   */
-  async close() {
-    await this.stop();
-  }
-}
-
-module.exports = { SandboxClient };