rl-rockcli 0.0.6 → 0.0.8

package/commands/sandbox-original.js

@@ -1,1393 +0,0 @@
-const { SandboxClient, SandboxConfig } = require('../utils/sandbox-client');
-const fs = require('fs-extra');
-const path = require('path');
-const logger = require('../utils/logger');
-const sessionCommand = require('./sandbox/session');
-const { gracefulExit } = require('../utils/execution_logger');
-const configManager = require('../utils/configManager');
-const { printNextStep, TIPS } = require('../utils/tips');
-
-const isOpenSource = process.env.ROCKCLI_MODE === 'opensource';
-const DEFAULT_OPEN_SOURCE_IMAGE = 'python:3.11';
-
-// 配置文件路径
-const CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.rock');
-const CONFIG_FILE = path.join(CONFIG_DIR, 'settings.json');
-
-/**
- * 读取配置文件中的 sandbox 配置
- * @param {Object} argv - Command line arguments
- * @returns {Object} - Sandbox config with proper priority for all parameters
- */
-function readSandboxConfig(argv = {}) {
-  const config = configManager.readConfig();
-  const sandboxConfig = config?.sandbox || {};
-
-  // Get default image from internal config or use open source default
-  let defaultImage;
-  if (isOpenSource) {
-    defaultImage = DEFAULT_OPEN_SOURCE_IMAGE;
-  } else {
-    const { getInternalSandboxConfig } = require('../sdks/sandbox/core/config');
-    const internalDefaults = getInternalSandboxConfig();
-    defaultImage = internalDefaults.image;
-  }
-
-  return {
-    base_url: argv.baseUrl || sandboxConfig.base_url || 'http://127.0.0.1:8080',
-    image: defaultImage,
-    api_key: configManager.getApiKeyWithPriority(argv),
-    cluster: configManager.getClusterWithPriority(argv),
-    user_id: configManager.getUserIdWithPriority(argv),
-    experiment_id: configManager.getExperimentIdWithPriority(argv),
-  };
-}
-
-// Sandbox command module for yargs
-module.exports = {
-  command: 'sandbox [action]',
-  describe: 'Sandbox operations:\n' +
-    '  start         启动一个新的 sandbox 实例\n' +
-    '  stop          停止指定的 sandbox 实例\n' +
-    '  execute       在 sandbox 中执行命令 (别名: exec)\n' +
-    '  exec          在 sandbox 中执行命令 (别名)\n' +
-    '  status        查看 sandbox 的运行状态\n' +
-    '  upload        上传文件或文件夹到 sandbox\n' +
-    '  download      从 sandbox 下载文件\n' +
-    '  write-file    在 sandbox 中写入文件\n' +
-    '  read-file     从 sandbox 读取文件\n' +
-    '  session       Session 管理 (create, run, close)\n' +
-    '  replay        回放请求列表 (从 stdin 读取 JSON)\n' +
-    '  build         构建 Docker 镜像（已废弃）\n' +
-    '  push          推送 Docker 镜像（已废弃）\n' +
-    '  run           运行容器（已废弃）',
-  builder: (yargs) => {
-    return yargs
-      .positional('action', {
-        describe: 'Sandbox action to perform, or a shell command to execute',
-        type: 'string',
-      })
-      .option('api-key', {
-        describe: 'API key for authentication',
-        type: 'string',
-        group: 'Command Options:'
-      })
-      .option('base-url', {
-        describe: 'Base URL for sandbox service',
-        type: 'string',
-        group: 'Command Options:'
-      })
-      .option('sandbox-id', {
-        alias: 'id',
-        describe: 'Sandbox ID (for operations on existing sandbox)',
-        type: 'string',
-        group: 'Command Options:'
-      })
-      .option('image', {
-        describe: 'Docker image to use',
-        type: 'string',
-        group: 'Command Options:'
-      })
-      .option('memory', {
-        describe: 'Memory limit',
-        type: 'string',
-        default: '8g',
-        group: 'Command Options:'
-      })
-      .option('cpus', {
-        describe: 'CPU limit',
-        type: 'number',
-        default: 2.0,
-        group: 'Command Options:'
-      })
-      .option('timeout', {
-        describe: 'Startup timeout in seconds',
-        type: 'number',
-        default: 120,
-        group: 'Command Options:'
-      })
-      .option('auto-clear', {
-        describe: 'Auto clear time in seconds',
-        type: 'number',
-        default: 300,
-        group: 'Command Options:'
-      })
-      .option('cluster', {
-        describe: 'Cluster ID (sets X-Cluster header)',
-        type: 'string',
-        group: 'Command Options:'
-      })
-      .option('experiment-id', {
-        describe: 'Experiment ID (sets X-Experiment-Id header)',
-        type: 'string',
-        group: 'Command Options:'
-      })
-      .option('user-id', {
-        describe: 'User ID (sets X-User-Id header)',
-        type: 'string',
-        group: 'Command Options:'
-      })
-      .option('command', {
-        describe: 'Command to execute',
-        type: 'string',
-        group: 'Command Options:'
-      })
-      .option('file', {
-        describe: 'File path for upload/download/read/write',
-        type: 'string',
-        group: 'Command Options:'
-      })
-      .option('dir', {
-        alias: 'd',
-        describe: 'Local directory path for upload (mutually exclusive with --file)',
-        type: 'string',
-        group: 'Command Options:'
-      })
-      .option('recursive', {
-        alias: 'r',
-        describe: 'Recursively upload subdirectories',
-        type: 'boolean',
-        default: false,
-        group: 'Command Options:'
-      })
-      .option('all', {
-        alias: 'a',
-        describe: 'Include hidden files (starting with .)',
-        type: 'boolean',
-        default: false,
-        group: 'Command Options:'
-      })
-      .option('clobber', {
-        alias: 'c',
-        describe: 'Overwrite existing files',
-        type: 'boolean',
-        default: false,
-        group: 'Command Options:'
-      })
-      .option('noclobber', {
-        alias: 'n',
-        describe: 'Do not overwrite existing files',
-        type: 'boolean',
-        default: false,
-        group: 'Command Options:'
-      })
-      .option('interactive', {
-        alias: 'i',
-        describe: 'Prompt before overwrite',
-        type: 'boolean',
-        default: false,
-        group: 'Command Options:'
-      })
-      .option('target-path', {
-        describe: 'Target path for upload/write',
-        type: 'string',
-        group: 'Command Options:'
-      })
-      .option('start-line', {
-        describe: 'Start line for read-file (1-indexed)',
-        type: 'number',
-        group: 'Command Options:'
-      })
-      .option('end-line', {
-        describe: 'End line for read-file (1-indexed)',
-        type: 'number',
-        group: 'Command Options:'
-      })
-      .option('content', {
-        describe: 'Content to write to file',
-        type: 'string',
-        group: 'Command Options:'
-      })
-      .option('extra-header', {
-        alias: 'H',
-        type: 'array',
-        description: 'Extra HTTP headers in format "Key=Value". Can be used multiple times.',
-        group: 'Command Options:',
-        coerce: (headers) => {
-          const result = {};
-          if (headers) {
-            headers.forEach(header => {
-              if (header.includes('=')) {
-                const [key, value] = header.split('=', 2);
-                result[key.trim()] = value.trim();
-              } else {
-                logger.warn(`Invalid header format: ${header}. Expected format: 'Key=Value'`);
-              }
-            });
-          }
-          return result;
-        }
-      })
-      .option('wait-for-alive', {
-        describe: 'Wait for sandbox to be alive before returning',
-        type: 'boolean',
-        default: false,
-        group: 'Command Options:'
-      })
-      .option('stop', {
-        describe: 'Execute stop request during replay (default: false)',
-        type: 'boolean',
-        default: false,
-        group: 'Command Options:'
-      })
-      .option('interval', {
-        describe: 'Interval between requests in seconds (default: 5, use 0 to disable waiting)',
-        type: 'number',
-        default: 5,
-        group: 'Command Options:'
-      })
-      .option('log-file', {
-        describe: 'Log file path to record replay details (default: replay.log)',
-        type: 'string',
-        default: 'replay.log',
-        group: 'Command Options:'
-      })
-      .option('raw', {
-        describe: 'Return raw JSON output instead of formatted text',
-        type: 'boolean',
-        default: false,
-        group: 'Command Options:'
-      })
-      .command(sessionCommand)
-      .example([
-        ['$0 --id <id> "ls -la"', 'Execute a command in sandbox'],
-        ['$0 --id <id> status', 'Get sandbox status'],
-        ['$0 --id <id> log', 'View sandbox logs'],
-        ['$0 attach <id>', 'Attach to sandbox (interactive REPL)'],
-        ['$0 sandbox start --image python:3.11', 'Start a new sandbox'],
-        ['$0 sandbox stop --id <id>', 'Stop a sandbox'],
-      ]);
-  },
-  handler: async (argv) => {
-    try {
-      // If no action is provided, show help
-      if (!argv.action) {
-        console.error('Error: action is required');
-        console.error('Use "rock-cli sandbox --help" for more information.');
-        gracefulExit(1);
-      }
-
-      // Known sandbox actions
-      const knownActions = ['start', 'stop', 'execute', 'exec', 'status', 'upload',
-        'download', 'write-file', 'read-file', 'replay', 'session',
-        'build', 'push', 'run'];
-
-      // If action is provided and not a known action, it's either:
-      // 1. 'log' - show logs
-      // 2. A shell command to execute
-      if (argv.action && !knownActions.includes(argv.action)) {
-        if (argv.action === 'log') {
-          // Show sandbox logs
-          return handleLogView(argv);
-        } else {
-          // Treat as shell command
-          argv.command = argv.action;
-          return handleExecute(argv);
-        }
-      }
-
-      switch (argv.action) {
-        case 'start':
-          await handleStart(argv);
-          break;
-        case 'stop':
-          await handleStop(argv);
-          break;
-        case 'execute':
-        case 'exec':
-          await handleExecute(argv);
-          break;
-        case 'status':
-          await handleStatus(argv);
-          break;
-        case 'upload':
-          await handleUpload(argv);
-          break;
-        case 'download':
-          await handleDownload(argv);
-          break;
-        case 'write-file':
-          await handleWriteFile(argv);
-          break;
-        case 'read-file':
-          await handleReadFile(argv);
-          break;
-        case 'replay':
-          await handleReplay(argv);
-          break;
-        case 'build':
-        case 'push':
-        case 'run':
-          await handleLegacyActions(argv);
-          break;
-        default:
-          console.error(`Unknown sandbox action: ${argv.action}`);
-          gracefulExit(1);
-      }
-    } catch (error) {
-      // Check for 401 authentication errors
-      if (error.response && error.response.status === 401) {
-        logger.error('Authentication failed: Invalid or missing API key');
-        console.error('\n💡 Please configure your API key:');
-        console.error('   Option 1: export ROCK_API_KEY=<your-key>');
-        console.error('   Option 2: Use --api-key flag: rc sandbox start --api-key <your-key>\n');
-      } else {
-        logger.error(`Sandbox action failed: ${error.message}`);
-      }
-      gracefulExit(1);
-    }
-  },
-};
-
-/**
- * Handle start action
- */
-async function handleStart(argv) {
-  const sandboxConfig = readSandboxConfig(argv);
-  const baseUrl = argv.baseUrl || sandboxConfig.base_url;
-  const apiKey = argv.apiKey || sandboxConfig.api_key;
-  const cluster = argv.cluster || sandboxConfig.cluster;
-  const userId = argv.userId || sandboxConfig.user_id;
-  const experimentId = argv.experimentId || sandboxConfig.experiment_id;
-  const image = argv.image || sandboxConfig.image;
-
-  if (!baseUrl) {
-    throw new Error('base-url is required for start action (use --base-url or run "rock-cli login" first)');
-  }
-
-  const config = new SandboxConfig({
-    baseUrl: baseUrl,
-    xrlAuthorization: apiKey,
-    image: image,
-    memory: argv.memory,
-    cpus: argv.cpus,
-    startupTimeout: argv.timeout,
-    autoClearSeconds: argv.autoClear,
-    cluster: cluster,
-    userId: userId,
-    experimentId: experimentId,
-    extraHeaders: argv.extraHeader || {},
-    waitForAlive: argv.waitForAlive,
-  });
-
-  const client = new SandboxClient(config);
-
-  if (!argv.raw) {
-    console.log(`Starting sandbox with image: ${config.image}...`);
-  }
-
-  const result = await client.start();
-
-  if (argv.raw) {
-    // Output raw JSON
-    console.log(JSON.stringify({
-      sandboxId: result.sandboxId,
-      hostName: result.hostName,
-      hostIp: result.hostIp,
-      isAlive: result.isAlive,
-      success: true
-    }));
-  } else {
-    console.log('✅ Sandbox started successfully!');
-    console.log(`   - Sandbox ID: ${result.sandboxId}`);
-    console.log(`   - Host Name: ${result.hostName}`);
-    console.log(`   - Host IP: ${result.hostIp}`);
-
-    if (argv.waitForAlive) {
-      console.log(`   - Status: ${result.isAlive ? '🟢 Ready' : '🟡 Starting...'}`);
-    }
-
-    // Show tip for next step
-    const tip = TIPS.afterStart(result.sandboxId);
-    printNextStep(tip.message, tip.command);
-  }
-}
-
-/**
- * Handle stop action
- */
-async function handleStop(argv) {
-  if (!argv.sandboxId) {
-    throw new Error('sandbox-id is required for stop action');
-  }
-
-  const sandboxConfig = readSandboxConfig(argv);
-  const baseUrl = argv.baseUrl || sandboxConfig.base_url;
-  const apiKey = argv.apiKey || sandboxConfig.api_key;
-  const cluster = argv.cluster || sandboxConfig.cluster;
-  const userId = argv.userId || sandboxConfig.user_id;
-  const experimentId = argv.experimentId || sandboxConfig.experiment_id;
-
-  if (!baseUrl) {
-    throw new Error('base-url is required for stop action (use --base-url or run "rock-cli login" first)');
-  }
-
-  const config = new SandboxConfig({
-    baseUrl: baseUrl,
-    xrlAuthorization: apiKey,
-    cluster: cluster,
-    userId: userId,
-    experimentId: experimentId,
-    extraHeaders: argv.extraHeader || {},
-  });
-
-  const client = new SandboxClient(config, { requireImage: false });
-  client._sandboxId = argv.sandboxId;
-
-  console.log(`Stopping sandbox: ${argv.sandboxId}...`);
-  await client.stop();
-  console.log('✅ Sandbox stopped successfully!');
-}
-
-/**
- * Handle execute action
- */
-async function handleExecute(argv) {
-  // Get command from --command option or from process.argv after --
-  let command = argv.command;
-  if (!command) {
-    const separatorIndex = process.argv.indexOf('--');
-    if (separatorIndex !== -1 && separatorIndex < process.argv.length - 1) {
-      command = process.argv.slice(separatorIndex + 1).join(' ');
-    }
-  }
-
-  if (!command) {
-    throw new Error('command is required. Use --command "your command" or: rock-cli sandbox execute --sandbox-id <id> --base-url <url> -- ps -aux');
-  }
-
-  if (!argv.sandboxId) {
-    throw new Error('sandbox-id is required for execute action');
-  }
-
-  const sandboxConfig = readSandboxConfig(argv);
-  const baseUrl = argv.baseUrl || sandboxConfig.base_url;
-  const apiKey = argv.apiKey || sandboxConfig.api_key;
-  const cluster = argv.cluster || sandboxConfig.cluster;
-  const userId = argv.userId || sandboxConfig.user_id;
-  const experimentId = argv.experimentId || sandboxConfig.experiment_id;
-
-  if (!baseUrl) {
-    throw new Error('base-url is required for execute action (use --base-url or run "rock-cli login" first)');
-  }
-
-  const config = new SandboxConfig({
-    baseUrl: baseUrl,
-    xrlAuthorization: apiKey,
-    cluster: cluster,
-    userId: userId,
-    experimentId: experimentId,
-    extraHeaders: argv.extraHeader || {},
-  });
-
-  const client = new SandboxClient(config, { requireImage: false });
-  client._sandboxId = argv.sandboxId;
-
-  console.log(`Executing command: ${command}`);
-  const result = await client.execute(command);
-
-  if (result.stdout) {
-    console.log('Output:');
-    console.log(result.stdout);
-  }
-
-  if (result.stderr) {
-    console.error('Errors:');
-    console.error(result.stderr);
-  }
-
-  console.log(`Exit code: ${result.exit_code}`);
-
-  if (result.exit_code !== 0) {
-    gracefulExit(1);
-  }
-}
-
-/**
- * Handle status action
- */
-async function handleStatus(argv) {
-  if (!argv.sandboxId) {
-    throw new Error('sandbox-id is required for status action');
-  }
-
-  const sandboxConfig = readSandboxConfig(argv);
-  const baseUrl = argv.baseUrl || sandboxConfig.base_url;
-  const apiKey = argv.apiKey || sandboxConfig.api_key;
-  const cluster = argv.cluster || sandboxConfig.cluster;
-  const userId = argv.userId || sandboxConfig.user_id;
-  const experimentId = argv.experimentId || sandboxConfig.experiment_id;
-
-  if (!baseUrl) {
-    throw new Error('base-url is required for status action (use --base-url or run "rock-cli login" first)');
-  }
-
-  const config = new SandboxConfig({
-    baseUrl: baseUrl,
-    xrlAuthorization: apiKey,
-    cluster: cluster,
-    userId: userId,
-    experimentId: experimentId,
-    extraHeaders: argv.extraHeader || {},
-  });
-
-  const client = new SandboxClient(config, { requireImage: false });
-  client._sandboxId = argv.sandboxId;
-
-  console.log(`Getting status for sandbox: ${argv.sandboxId}...`);
-  const status = await client.getStatus();
-
-  console.log('📊 Sandbox Status:');
-  console.log(`   - Sandbox ID: ${status.sandboxId}`);
-  console.log(`   - Cluster: ${status.cluster || 'N/A'}`);
-  console.log(`   - Host Name: ${status.hostName || 'N/A'}`);
-  console.log(`   - Host IP: ${status.hostIp || 'N/A'}`);
-  console.log(`   - Alive: ${status.isAlive ? '🟢 Yes' : '🔴 No'}`);
-  console.log(`   - Image: ${status.image || 'N/A'}`);
-  console.log(`   - CPUs: ${status.cpus || 'N/A'}`);
-  console.log(`   - Memory: ${status.memory || 'N/A'}`);
-  console.log(`   - Namespace: ${status.namespace || 'N/A'}`);
-  console.log(`   - Request ID: ${status.requestId || 'N/A'}`);
-  console.log(`   - EagleEye Trace ID: ${status.eagleeyeTraceid || 'N/A'}`);
-
-  if (status.portMapping && Object.keys(status.portMapping).length > 0) {
-    console.log(`   - Port Mappings:`);
-    for (const [containerPort, hostPort] of Object.entries(status.portMapping)) {
-      console.log(`     - ${containerPort} -> ${hostPort}`);
-    }
-  }
-
-  if (status.status) {
-    console.log(`   - Stage Status:`);
-    for (const [stage, details] of Object.entries(status.status)) {
-      const icon = details.status === 'success' ? '✅' : details.status === 'failed' ? '❌' : '⏳';
-      console.log(`     - ${icon} ${stage}: ${details.status}`);
-      if (details.message) {
-        console.log(`       ${details.message}`);
-      }
-    }
-  }
-}
-
-/**
- * Handle upload action
- */
-async function handleUpload(argv) {
-  // Check mutual exclusivity
-  if (argv.file && argv.dir) {
-    throw new Error('--file and --dir are mutually exclusive');
-  }
-
-  if (!argv.file && !argv.dir) {
-    throw new Error('--file or --dir is required for upload action');
-  }
-
-  if (!argv.targetPath) {
-    throw new Error('target-path is required for upload action');
-  }
-
-  if (!argv.sandboxId) {
-    throw new Error('sandbox-id is required for upload action');
-  }
-
-  const sandboxConfig = readSandboxConfig(argv);
-  const baseUrl = argv.baseUrl || sandboxConfig.base_url;
-  const apiKey = argv.apiKey || sandboxConfig.api_key;
-  const cluster = argv.cluster || sandboxConfig.cluster;
-  const userId = argv.userId || sandboxConfig.user_id;
-  const experimentId = argv.experimentId || sandboxConfig.experiment_id;
-
-  if (!baseUrl) {
-    throw new Error('base-url is required for upload action (use --base-url or run "rock-cli login" first)');
-  }
-
-  const config = new SandboxConfig({
-    baseUrl: baseUrl,
-    xrlAuthorization: apiKey,
-    cluster: cluster,
-    userId: userId,
-    experimentId: experimentId,
-    extraHeaders: argv.extraHeader || {},
-  });
-
-  const client = new SandboxClient(config, { requireImage: false });
-  client._sandboxId = argv.sandboxId;
-
-  // Branch: directory upload or single file upload
-  if (argv.dir) {
-    await handleDirectoryUpload(argv, client);
-  } else {
-    console.log(`Uploading ${argv.file} to ${argv.targetPath}...`);
-    const result = await client.uploadFile(argv.file, argv.targetPath);
-
-    if (result.success) {
-      console.log('Upload successful!');
-      console.log(`   ${result.message}`);
-    } else {
-      console.error('Upload failed!');
-      console.error(`   ${result.message}`);
-      gracefulExit(1);
-    }
-  }
-}
-
-/**
- * Escape string for shell command
- */
-function shellEscape(str) {
-  return `'${str.replace(/'/g, "'\\''")}'`;
-}
-
-/**
- * Collect files from a local directory
- */
-function collectFiles(dir, options) {
-  const { recursive, includeHidden } = options;
-  const files = [];
-
-  function walk(currentDir, relativePath) {
-    const entries = fs.readdirSync(currentDir, { withFileTypes: true });
-
-    for (const entry of entries) {
-      // Filter hidden files
-      if (!includeHidden && entry.name.startsWith('.')) {
-        continue;
-      }
-
-      // Skip symbolic links
-      if (entry.isSymbolicLink()) {
-        logger.debug(`Skipping symlink: ${path.join(currentDir, entry.name)}`);
-        continue;
-      }
-
-      const fullPath = path.join(currentDir, entry.name);
-      const relPath = relativePath ? path.join(relativePath, entry.name) : entry.name;
-
-      if (entry.isFile()) {
-        files.push({ localPath: fullPath, relativePath: relPath });
-      } else if (entry.isDirectory() && recursive) {
-        walk(fullPath, relPath);
-      }
-    }
-  }
-
-  walk(dir, '');
-  return files;
-}
-
-/**
- * Get list of existing files in remote directory
- */
-async function getRemoteFileList(client, targetPath, recursive) {
-  const normalizedPath = targetPath.replace(/\/+$/, '');
-
-  try {
-    // Use simple ls or find command, handle errors gracefully
-    let result;
-    if (recursive) {
-      // For recursive, use find
-      result = await client.execute(['find', normalizedPath, '-type', 'f']);
-    } else {
-      // For non-recursive, use ls -1A to include hidden files (but exclude . and ..)
-      result = await client.execute(['ls', '-1A', normalizedPath]);
-    }
-
-    const files = new Set();
-    if (result.exit_code === 0 && result.stdout) {
-      String(result.stdout).split('\n').filter(Boolean).forEach(f => {
-        // find returns full path, ls returns filename only
-        const fullPath = recursive ? f : path.posix.join(normalizedPath, f);
-        files.add(fullPath);
-      });
-    }
-    logger.debug(`getRemoteFileList: path=${targetPath}, recursive=${recursive}, found=${files.size} files`);
-    return files;
-  } catch (error) {
-    // Return empty set if directory doesn't exist
-    logger.debug(`getRemoteFileList error: ${error.message}`);
-    return new Set();
-  }
-}
-
-/**
- * Validate that an API key is available
- * @param {Object} argv - Command line arguments
- * @returns {string} - The API key
- * @throws {Error} - If no API key is available
- */
-function validateAuth(argv) {
-  const apiKey = configManager.getApiKeyWithPriority(argv);
-  if (!apiKey) {
-    throw new Error(
-      'API key required. Set ROCK_API_KEY environment variable ' +
-      'or use --api-key flag'
-    );
-  }
-  return apiKey;
-}
-
-// Export getRemoteFileList for testing
-module.exports.getRemoteFileList = getRemoteFileList;
-
-// Export readSandboxConfig for testing
-module.exports.readSandboxConfig = readSandboxConfig;
-
-// Export validateAuth for testing
-module.exports.validateAuth = validateAuth;
-
-/**
- * Ask user for confirmation (interactive mode)
- */
-async function askUser(question) {
-  const readline = require('readline');
-  const rl = readline.createInterface({
-    input: process.stdin,
-    output: process.stdout
-  });
-
-  return new Promise((resolve) => {
-    rl.question(question, (answer) => {
-      rl.close();
-      resolve(answer.toLowerCase().trim());
-    });
-  });
-}
-
-/**
- * Print upload summary
- */
-function printUploadSummary(total, results) {
-  console.log('\nUpload Summary:');
-  console.log(`  Total files: ${total}`);
-  console.log(`  Uploaded:    ${results.uploaded}`);
-  console.log(`  Skipped:     ${results.skipped} (already exists)`);
-  console.log(`  Failed:      ${results.failed}`);
-
-  if (results.failedFiles.length > 0) {
-    console.log('\nFailed files:');
-    results.failedFiles.forEach(f => {
-      console.log(`  - ${f.path}: ${f.error}`);
-    });
-  }
-}
-
-/**
- * Handle directory upload
- */
-async function handleDirectoryUpload(argv, client) {
-  const localDir = path.resolve(argv.dir);
-  const targetPath = argv.targetPath.replace(/\/+$/, ''); // Normalize: remove trailing slashes
-  const recursive = argv.recursive || false;
-  const includeHidden = argv.all || false;
-  const noclobber = argv.noclobber || false;
-  const clobber = argv.clobber || false;
-  const interactive = argv.interactive || false;
-
-  // Validate local directory
-  if (!fs.existsSync(localDir)) {
-    throw new Error(`Directory not found: ${localDir}`);
-  }
-
-  const stat = fs.statSync(localDir);
-  if (!stat.isDirectory()) {
-    throw new Error(`Not a directory: ${localDir}`);
-  }
-
-  // Collect files
-  console.log(`Scanning directory: ${localDir}`);
-  const files = collectFiles(localDir, { recursive, includeHidden });
-
-  if (files.length === 0) {
-    console.log('No files to upload');
-    return;
-  }
-
-  console.log(`Found ${files.length} file(s) to upload`);
-  console.log(`Uploading to: ${targetPath}\n`);
-
-  // Get remote file list for conflict detection
-  const existingFiles = await getRemoteFileList(client, targetPath, recursive);
-  logger.debug(`Remote files found: ${existingFiles.size}`);
-
-  // Determine conflict strategy
-  // -n (noclobber) takes precedence: skip existing files
-  // -c (clobber) takes second precedence: overwrite existing files
-  // -i (interactive): ask before overwriting
-  // default: skip existing files
-  const conflictStrategy = noclobber ? 'skip' : (clobber ? 'overwrite' : (interactive ? 'ask' : 'skip'));
-
-  // Upload files
-  const results = { uploaded: 0, skipped: 0, failed: 0, failedFiles: [] };
-  const total = files.length;
-
-  for (let i = 0; i < files.length; i++) {
-    const file = files[i];
-    // Convert to POSIX path for remote
-    const posixRelativePath = file.relativePath.split(path.sep).join('/');
-    const remoteFilePath = path.posix.join(targetPath, posixRelativePath);
-    const remoteDir = path.posix.dirname(remoteFilePath);
-
-    // Conflict detection
-    if (existingFiles.has(remoteFilePath)) {
-      if (conflictStrategy === 'skip') {
-        console.log(`[${i + 1}/${total}] Skipped (exists): ${posixRelativePath}`);
-        results.skipped++;
-        continue;
-      } else if (conflictStrategy === 'ask') {
-        const answer = await askUser(`Overwrite ${remoteFilePath}? [y/n]: `);
-        if (answer !== 'y') {
-          console.log(`[${i + 1}/${total}] Skipped: ${posixRelativePath}`);
-          results.skipped++;
-          continue;
-        }
-      }
-      // 'overwrite': continue to upload
-    } else {
-      logger.debug(`File not in remote list: ${remoteFilePath}, strategy: ${conflictStrategy}`);
-    }
-
-    console.log(`[${i + 1}/${total}] Uploading: ${posixRelativePath}`);
-
-    try {
-      // Create remote parent directory if needed (for recursive uploads)
-      if (recursive && remoteDir !== targetPath) {
-        await client.execute(['mkdir', '-p', remoteDir]);
-      }
-
-      // Upload file
-      const result = await client.uploadFile(file.localPath, remoteFilePath);
-      if (result.success) {
-        results.uploaded++;
-      } else {
-        results.failed++;
-        results.failedFiles.push({ path: posixRelativePath, error: result.message });
-        console.log(`[${i + 1}/${total}] Failed: ${posixRelativePath} - ${result.message}`);
-      }
-    } catch (error) {
-      results.failed++;
-      results.failedFiles.push({ path: posixRelativePath, error: error.message });
-      console.log(`[${i + 1}/${total}] Failed: ${posixRelativePath} - ${error.message}`);
-    }
-  }
-
-  // Print summary
-  printUploadSummary(total, results);
-
-  // Exit with error if all files failed
-  if (results.failed === total) {
-    gracefulExit(1);
-  }
-}
-
-/**
- * Handle download action
- */
-async function handleDownload(argv) {
-  if (!argv.file) {
-    throw new Error('file is required for download action');
-  }
-
-  if (!argv.sandboxId) {
-    throw new Error('sandbox-id is required for download action');
-  }
-
-  const sandboxConfig = readSandboxConfig(argv);
-  const baseUrl = argv.baseUrl || sandboxConfig.base_url;
-  const apiKey = argv.apiKey || sandboxConfig.api_key;
-  const cluster = argv.cluster || sandboxConfig.cluster;
-  const userId = argv.userId || sandboxConfig.user_id;
-  const experimentId = argv.experimentId || sandboxConfig.experiment_id;
-
-  if (!baseUrl) {
-    throw new Error('base-url is required for download action (use --base-url or run "rock-cli login" first)');
-  }
-
-  const config = new SandboxConfig({
-    baseUrl: baseUrl,
-    xrlAuthorization: apiKey,
-    cluster: cluster,
-    userId: userId,
-    experimentId: experimentId,
-    extraHeaders: argv.extraHeader || {},
-  });
-
-  const client = new SandboxClient(config, { requireImage: false });
-  client._sandboxId = argv.sandboxId;
-
-  console.log(`Downloading ${argv.file}...`);
-  const result = await client.downloadFile(argv.file);
-
-  console.log('✅ Download successful!');
-  console.log(`   File: ${argv.file}`);
-  console.log(`   Content: ${JSON.stringify(result, null, 2)}`);
-}
-
-/**
- * Handle write-file action
- */
-async function handleWriteFile(argv) {
-  if (!argv.content) {
-    throw new Error('content is required for write-file action');
-  }
-
-  if (!argv.targetPath) {
-    throw new Error('target-path is required for write-file action');
-  }
-
-  if (!argv.sandboxId) {
-    throw new Error('sandbox-id is required for write-file action');
-  }
-
-  const sandboxConfig = readSandboxConfig(argv);
-  const baseUrl = argv.baseUrl || sandboxConfig.base_url;
-  const apiKey = argv.apiKey || sandboxConfig.api_key;
-  const cluster = argv.cluster || sandboxConfig.cluster;
-  const userId = argv.userId || sandboxConfig.user_id;
-  const experimentId = argv.experimentId || sandboxConfig.experiment_id;
-
-  if (!baseUrl) {
-    throw new Error('base-url is required for write-file action (use --base-url or run "rock-cli login" first)');
-  }
-
-  const config = new SandboxConfig({
-    baseUrl: baseUrl,
-    xrlAuthorization: apiKey,
-    cluster: cluster,
-    userId: userId,
-    experimentId: experimentId,
-    extraHeaders: argv.extraHeader || {},
-  });
-
-  const client = new SandboxClient(config, { requireImage: false });
-  client._sandboxId = argv.sandboxId;
-
-  console.log(`Writing content to ${argv.targetPath}...`);
-  const result = await client.writeFile(argv.content, argv.targetPath);
-
-  if (result.success) {
-    console.log('✅ Write successful!');
-    console.log(`   ${result.message}`);
-  } else {
-    console.error('❌ Write failed!');
-    console.error(`   ${result.message}`);
-    gracefulExit(1);
-  }
-}
-
-/**
- * Handle read-file action
- */
-async function handleReadFile(argv) {
-  if (!argv.file) {
-    throw new Error('file is required for read-file action');
-  }
-
-  if (!argv.sandboxId) {
-    throw new Error('sandbox-id is required for read-file action');
-  }
-
-  const sandboxConfig = readSandboxConfig(argv);
-  const baseUrl = argv.baseUrl || sandboxConfig.base_url;
-  const apiKey = argv.apiKey || sandboxConfig.api_key;
-  const cluster = argv.cluster || sandboxConfig.cluster;
-  const userId = argv.userId || sandboxConfig.user_id;
-  const experimentId = argv.experimentId || sandboxConfig.experiment_id;
-
-  if (!baseUrl) {
-    throw new Error('base-url is required for read-file action (use --base-url or run "rock-cli login" first)');
-  }
-
-  const config = new SandboxConfig({
-    baseUrl: baseUrl,
-    xrlAuthorization: apiKey,
-    cluster: cluster,
-    userId: userId,
-    experimentId: experimentId,
-    extraHeaders: argv.extraHeader || {},
-  });
-
-  const client = new SandboxClient(config, { requireImage: false });
-  client._sandboxId = argv.sandboxId;
-
-  let startLine = argv.startLine || 1;
-  let endLine = argv.endLine || 1000;
-
-  console.log(`Reading ${argv.file} (lines ${startLine}-${endLine})...`);
-  const result = await client.readFile(argv.file, startLine, endLine);
-
-  console.log('✅ Read successful!');
-  console.log('--- Content ---');
-  console.log(result.content);
-  console.log('--- End ---');
-}
-
-/**
- * Handle log view action (shorthand: sandbox --id xxx log)
- */
-async function handleLogView(argv) {
-  const sandboxId = argv.id || argv.sandboxId;
-  if (!sandboxId) {
-    console.error('Error: sandbox-id is required');
-    process.exit(1);
-  }
-  const { spawn } = require('child_process');
-  spawn('node', [path.join(__dirname, '../all.js'), 'log', 'search', '--sandbox-id', sandboxId], {
-    stdio: 'inherit',
-  });
-}
-
-/**
- * Wait for sandbox to be alive
- * @param {SandboxClient} client - Sandbox client instance
- * @param {string} sandboxId - Sandbox ID to check
- * @param {number} timeout - Timeout in seconds (default: 120)
- */
-async function waitForSandboxAlive(client, sandboxId, timeout = 120) {
-  const startTime = Date.now();
-  const timeoutMs = timeout * 1000;
-
-  while (Date.now() - startTime < timeoutMs) {
-    try {
-      const status = await client.getStatus();
-      logger.debug(`Sandbox status: ${JSON.stringify(status)}`);
-
-      if (status.isAlive) {
-        return;
-      }
-
-      // 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') {
-              logger.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));
-    } catch (error) {
-      logger.warn(`Failed to check sandbox status: ${error.message}`);
-      throw error;
-    }
-  }
-
-  throw new Error(`Sandbox did not become alive within ${timeout}s`);
-}
-
-/**
- * Handle replay action
- */
-async function handleReplay(argv) {
-  const sandboxConfig = readSandboxConfig(argv);
-  const baseUrl = argv.baseUrl || sandboxConfig.base_url;
-  const apiKey = argv.apiKey || sandboxConfig.api_key;
-  const cluster = argv.cluster || sandboxConfig.cluster;
-  const userId = argv.userId || sandboxConfig.user_id;
-  const experimentId = argv.experimentId || sandboxConfig.experiment_id;
-
-  if (!baseUrl) {
-    throw new Error('base-url is required for relay action (use --base-url or run "rock-cli login" first)');
-  }
-
-  const config = new SandboxConfig({
-    baseUrl: baseUrl,
-    xrlAuthorization: apiKey,
-    cluster: cluster,
-    userId: userId,
-    experimentId: experimentId,
-    extraHeaders: argv.extraHeader || {},
-  });
-
-  const client = new SandboxClient(config, { requireImage: false });
-
-  // Initialize log file
-  const fs = require('fs');
-  const path = require('path');
-  const logFilePath = argv.logFile || 'replay.log';
-  const logStream = fs.createWriteStream(logFilePath, { flags: 'a' });
-
-  const logToFile = (message) => {
-    const timestamp = new Date().toISOString();
-    logStream.write(`[${timestamp}] ${message}\n`);
-  };
-
-  logToFile('=== Replay Session Started ===');
-  logToFile(`Base URL: ${baseUrl}`);
-  logToFile(`Cluster: ${argv.cluster || 'default'}`);
-  logToFile(`Interval: ${argv.interval}s`);
-  logToFile(`Stop requests: ${argv.stop ? 'enabled' : 'disabled'}`);
-
-  // Read JSON from stdin
-  let inputData = '';
-  return new Promise((resolve, reject) => {
-    process.stdin.setEncoding('utf8');
-    process.stdin.on('data', (chunk) => {
-      inputData += chunk;
-    });
-    process.stdin.on('end', async () => {
-      try {
-        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');
-        }
-
-        logToFile(`Loaded ${data.requests.length} requests to replay`);
-        console.log(`📋 Loaded ${data.requests.length} requests to replay`);
-        console.log(`📝 Logging to: ${logFilePath}`);
-        console.log('⏳ Starting request replay...\n');
-
-        let successCount = 0;
-        let failCount = 0;
-        let currentSandboxId = null;
-
-        for (let i = 0; i < data.requests.length; i++) {
-          const request = data.requests[i];
-          const requestNum = i + 1;
-
-          // Replace sandbox_id in request if we have a current one
-          if (currentSandboxId) {
-            // Replace sandbox_id in request body
-            if (request.requestBody && request.requestBody.sandbox_id) {
-              request.requestBody.sandbox_id = currentSandboxId;
-              logger.debug(`Replaced sandbox_id in body with: ${currentSandboxId}`);
-            }
-            // Replace sandbox_id in URI query parameter
-            if (request.uri.includes('sandbox_id=')) {
-              request.uri = request.uri.replace(/sandbox_id=[^&]+/, `sandbox_id=${currentSandboxId}`);
-              logger.debug(`Replaced sandbox_id in URI with: ${currentSandboxId}`);
-            }
-          }
-
-          console.log(`[${requestNum}/${data.requests.length}] ${request.method} ${request.uri}`);
-          logToFile(`[${requestNum}/${data.requests.length}] ${request.method} ${request.uri}`);
-          logToFile(`   Request Body: ${JSON.stringify(request.requestBody || null)}`);
-          logToFile(`   Headers: ${JSON.stringify(request.headers || null)}`);
-
-          // Skip stop request unless --stop flag is provided
-          if (request.uri.includes('/stop')) {
-            if (!argv.stop) {
-              console.log(`   ⏭️  Skipped (use --stop to execute stop requests)`);
-              logToFile(`   ⏭️  Skipped (stop requests disabled)`);
-              continue;
-            }
-          }
-
-          const requestStartTime = Date.now();
-          try {
-            let response;
-            // Handle upload request specially
-            if (request.uri.includes('upload') && request.requestBody && request.requestBody.file) {
-              const fileData = request.requestBody.file;
-              const filename = fileData.filename;
-              const content = fileData.content;
-              const targetPath = request.requestBody.target_path || `/tmp/${filename}`;
-
-              logger.debug(`Handling upload request: ${filename} -> ${targetPath}`);
-
-              // Write content to a temporary file
-              const fs = require('fs');
-              const os = require('os');
-              const path = require('path');
-              const tempDir = os.tmpdir();
-              const tempFilePath = path.join(tempDir, filename);
-
-              // Decode file content (base64 or escaped binary)
-              let fileBuffer;
-              if (fileData.isBase64) {
-                fileBuffer = Buffer.from(content, 'base64');
-              } else {
-                // Fallback: parse escaped binary string for backward compatibility
-                const 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);
-                };
-                fileBuffer = parseEscapedBinary(content);
-              }
-
-              fs.writeFileSync(tempFilePath, fileBuffer);
-              logger.debug(`Created temporary file: ${tempFilePath} (${fileBuffer.length} bytes)`);
-              logger.debug(`First 16 bytes: ${fileBuffer.slice(0, 16).toString('hex')}`);
-
-              // Set sandbox_id for client
-              client._sandboxId = currentSandboxId;
-
-              // Use SDK's uploadFile method
-              const result = await client.uploadFile(tempFilePath, targetPath);
-
-              // Clean up temp file
-              fs.unlinkSync(tempFilePath);
-
-              if (result.success) {
-                successCount++;
-                const duration = Date.now() - requestStartTime;
-                console.log(`   ✅ Success`);
-                logToFile(`   ✅ Success - Duration: ${duration}ms - Message: ${result.message}`);
-                logToFile(`   Response Body: ${JSON.stringify(result)}`);
-                logToFile(`   Response Headers: ${JSON.stringify(result.headers || {})}`);
-                logger.debug(`   Upload result: ${result.message}`);
-              } else {
-                throw new Error(result.message);
-              }
-            } else {
-              // Use generic makeRequest for other requests
-              response = await client.makeRequest(request);
-              successCount++;
-              const duration = Date.now() - requestStartTime;
-              console.log(`   ✅ Success - Status: ${response.status || 200}`);
-              logToFile(`   ✅ Success - Status: ${response.status || 200} - Duration: ${duration}ms`);
-              logToFile(`   Response Body: ${JSON.stringify(response.data)}`);
-              logToFile(`   Response Headers: ${JSON.stringify(response.headers || {})}`);
-              logger.debug(`   Response: ${JSON.stringify(response)}`);
-            }
-
-            // Check if this is a start_async request and extract sandbox_id
-            if (request.uri.includes('start_async') && response && response.data && response.data.result && response.data.result.sandbox_id) {
-              currentSandboxId = response.data.result.sandbox_id;
-              console.log(`   📝 Extracted sandbox_id: ${currentSandboxId}`);
-              logToFile(`   📝 Extracted sandbox_id: ${currentSandboxId}`);
-            }
-          } catch (error) {
-            failCount++;
-            const duration = Date.now() - requestStartTime;
-            console.log(`   ❌ Failed - ${error.message}`);
-            logToFile(`   ❌ Failed - Duration: ${duration}ms - Error: ${error.message}`);
-
-            // For axios errors, log the backend response data instead of stack trace
-            if (error.response && error.response.data) {
-              logToFile(`   Response Data: ${JSON.stringify(error.response.data)}`);
-            }
-
-            logger.error(`Request ${requestNum} failed: ${error.message}`);
-          }
-
-          // Wait between requests (except for the last one)
-          if (i < data.requests.length - 1) {
-            if (request.uri.includes('start_async')) {
-              // Wait for sandbox to be alive after start_async
-              console.log('   ⏳ Waiting for sandbox to be alive...');
-              logToFile(`   ⏳ Waiting for sandbox to be alive...`);
-              client._sandboxId = currentSandboxId;
-              await waitForSandboxAlive(client, currentSandboxId);
-              console.log('   ✅ Sandbox is alive!\n');
-              logToFile(`   ✅ Sandbox is alive!`);
-            } else if (argv.interval > 0) {
-              // Wait for specified interval
-              console.log(`   ⏸️  Waiting ${argv.interval} seconds...\n`);
-              logToFile(`   ⏸️  Waiting ${argv.interval} seconds...`);
-              await new Promise(resolve => setTimeout(resolve, argv.interval * 1000));
-            } else {
-              console.log();
-            }
-          } else {
-            console.log();
-          }
-        }
-
-        console.log('📊 Replay Summary:');
-        console.log(`   - Total requests: ${data.requests.length}`);
-        console.log(`   - ✅ Successful: ${successCount}`);
-        console.log(`   - ❌ Failed: ${failCount}`);
-
-        logToFile('=== Replay Summary ===');
-        logToFile(`Total requests: ${data.requests.length}`);
-        logToFile(`Successful: ${successCount}`);
-        logToFile(`Failed: ${failCount}`);
-        logToFile('=== Replay Session Ended ===');
-
-        logStream.end();
-        console.log(`📝 Log saved to: ${logFilePath}`);
-
-        resolve();
-      } catch (error) {
-        logToFile(`ERROR: ${error.message}`);
-        logStream.end();
-        reject(error);
-      }
-    });
-    process.stdin.on('error', (error) => {
-      logToFile(`ERROR: Error reading from stdin: ${error.message}`);
-      logStream.end();
-      reject(new Error(`Error reading from stdin: ${error.message}`));
-    });
-  });
-}
-
-/**
- * Handle legacy build, push, run actions (backward compatibility)
- */
-async function handleLegacyActions(argv) {
-  const { exec } = require('child_process');
-  const util = require('util');
-  const execAsync = util.promisify(exec);
-
-  switch (argv.action) {
-    case 'build':
-      if (!argv.tag) {
-        throw new Error('tag is required for build action');
-      }
-      let dockerCommand = `docker build -t ${argv.tag} -f ${argv.file || 'Dockerfile'} .`;
-      if (argv.cpus) dockerCommand += ` --cpus=${argv.cpus}`;
-      if (argv.memory) dockerCommand += ` --memory=${argv.memory}`;
-
-      console.log(`Building sandbox: ${dockerCommand}`);
-      const { stdout, stderr } = await execAsync(dockerCommand);
-      console.log(stdout);
-      if (stderr) console.error(stderr);
-      console.log('✅ Build successful!');
-      break;
-
-    case 'push':
-      if (!argv.image) {
-        throw new Error('image is required for push action');
-      }
-      const registry = argv.registry || 'docker.io';
-      const tagCommand = `docker tag ${argv.image} ${registry}/${argv.image}`;
-      await execAsync(tagCommand);
-
-      const pushCommand = `docker push ${registry}/${argv.image}`;
-      console.log(`Pushing: ${pushCommand}`);
-      const pushResult = await execAsync(pushCommand);
-      console.log(pushResult.stdout);
-      console.log('✅ Push successful!');
-      break;
-
-    case 'run':
-      console.log('Note: Use "rock-cli sandbox start" + "rock-cli sandbox execute" for run functionality');
-      console.log('The legacy "run" action is deprecated and will be removed in a future version');
-      break;
-  }
-}