rl-rockcli 0.0.8 → 0.0.9

package/commands/sandbox-original.js

@@ -0,0 +1,1393 @@
+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 || process.env.ROCKCLI_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;
+  }
+}