rl-rockcli 0.0.8 → 0.0.10

package/commands/sandbox.js

@@ -0,0 +1,499 @@
+const { SandboxClient, SandboxConfig } = require('../utils/sandbox-client');
+const fs = require('fs-extra');
+const path = require('path');
+const logger = require('../utils/logger');
+const { routeSandboxCommand, showDeprecatedWarning } = require('../utils/command-router');
+const { handleSandboxLogSearch, handleSandboxLogTail } = require('./sandbox/log-bridge');
+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_BASE_URL = 'http://127.0.0.1:8080';
+const DEFAULT_OPEN_SOURCE_IMAGE = 'python:3.11';
+
+// Import existing sandbox.js handlers
+const sandboxOriginal = require('./sandbox-original');
+
+/**
+ * 读取配置文件中的 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 || {};
+  const envBaseUrl = process.env.ROCKCLI_BASE_URL;
+
+  const baseUrl =
+    argv.baseUrl ||
+    envBaseUrl ||
+    sandboxConfig.base_url ||
+    (isOpenSource ? DEFAULT_OPEN_SOURCE_BASE_URL : 'http://127.0.0.1:8080');
+
+  // 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: baseUrl,
+    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 - NEW FORMAT
+const sandboxExports = module.exports = {
+  command: 'sandbox [id] [command]',
+  describe: 'Sandbox instance management',
+  builder: (yargs) => {
+    return yargs
+      .positional('id', {
+        describe: 'Sandbox ID (for operations on existing sandbox)',
+        type: 'string',
+      })
+      .positional('command', {
+        describe: 'Sandbox command to perform',
+        type: 'string',
+      })
+      .strict(false) // Allow unknown options (they will be passed to subcommands like log search)
+      .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('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', {
+        alias: 'c',
+        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('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('n', {
+        alias: 'lines',
+        describe: 'Number of recent log lines to display (default: 10)',
+        type: 'number',
+        default: 10,
+        group: 'Log Options:'
+      })
+      .option('f', {
+        alias: 'follow',
+        describe: 'Follow mode: continuously monitor logs (like tail -f)',
+        type: 'boolean',
+        default: false,
+        group: 'Log Options:'
+      })
+      .option('sleep-interval', {
+        alias: 'i',
+        describe: 'Refresh interval in seconds for follow mode (default: 5)',
+        type: 'number',
+        default: 5,
+        group: 'Log Options:'
+      })
+      .option('q', {
+        alias: 'quiet',
+        describe: 'Quiet mode: hide internal fields (timestamp, time_iso8601, etc.)',
+        type: 'boolean',
+        default: false,
+        group: 'Log Options:'
+      })
+      .option('keyword', {
+        alias: 'k',
+        describe: 'Filter logs by keyword',
+        type: 'string',
+        group: 'Log Options:'
+      })
+      .option('log-file', {
+        describe: 'Filter by log file name',
+        type: 'string',
+        group: 'Log Options:'
+      })
+      .option('debug', {
+        describe: 'Enable debug mode to display SQL query',
+        type: 'boolean',
+        default: false,
+        group: 'Log Options:'
+      })
+      .option('raw', {
+        describe: 'Display raw output (flatten to single line)',
+        type: 'boolean',
+        default: false,
+        group: 'Log Options:'
+      })
+      .option('multilines', {
+        describe: 'Display multi-line logs with separators',
+        type: 'boolean',
+        default: false,
+        group: 'Log Options:'
+      })
+      .option('highlight', {
+        describe: 'Enable keyword highlighting (default: true)',
+        type: 'boolean',
+        default: true,
+        group: 'Log Options:'
+      })
+      .example([
+        ['$0 sandbox start --image python:3.11', 'Start a new sandbox'],
+        ['$0 sandbox <id> status', 'Get sandbox status'],
+        ['$0 sandbox <id> attach', 'Attach to sandbox (interactive REPL)'],
+        ['$0 sandbox <id> exec -- ls -la', 'Execute command in sandbox'],
+      ]);
+  },
+  handler: async (argv) => {
+    try {
+      // Rebuild argv._ from process.argv to preserve all original arguments
+      // This is needed because yargs parses positional parameters separately
+      const rawArgs = process.argv.slice(2);
+
+      // Filter out options (args starting with -) from argv._
+      // This is needed because global options like -vvv should not be treated as positional args
+      argv._ = rawArgs.filter(arg => !arg.startsWith('-'));
+
+      const commandType = routeSandboxCommand(argv);
+
+      if (commandType === 'help') {
+        const { renderHelp } = require('../help/renderer');
+        console.log(renderHelp(['sandbox']));
+        gracefulExit(0);
+        return;
+      }
+
+      if (commandType === 'sandbox-start') {
+        // Handle start command
+        await sandboxOriginal.handler({
+          ...argv,
+          action: 'start'
+        });
+        return;
+      }
+
+      if (commandType === 'sandbox-id-first') {
+        // Handle <id> <command> format
+        const id = argv.id;
+        if (!id) {
+          console.error('Error: Sandbox ID is required');
+          gracefulExit(1);
+          return;
+        }
+
+        const command = argv.command;
+        if (!command) {
+          console.error('Error: Command is required');
+          gracefulExit(1);
+          return;
+        }
+
+        // Route to appropriate handler
+        await handleIdFirstCommand(id, command, argv);
+        return;
+      }
+
+      if (commandType === 'sandbox-session') {
+        // Handle session commands (deprecated)
+        showDeprecatedWarning('sandbox session', 'sandbox <id> exec --session <action>');
+
+        // Use original handler for now
+        await sandboxOriginal.handler(argv);
+        return;
+      }
+
+      // Default: use original handler
+      await sandboxOriginal.handler(argv);
+
+    } catch (error) {
+      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 --id <id> --api-key <your-key>\n');
+      } else {
+        logger.error(`Sandbox action failed: ${error.message}`);
+      }
+      gracefulExit(1);
+    }
+  },
+};
+
+/**
+ * Handle <id> <command> format
+ * @param {string} id - Sandbox ID
+ * @param {string} command - Command to execute
+ * @param {Object} argv - Command line arguments
+ */
+async function handleIdFirstCommand(id, command, argv) {
+  // Set sandboxId in argv
+  argv.sandboxId = id;
+  argv.id = id;
+
+  switch (command) {
+    case 'status':
+      await sandboxOriginal.handler({
+        ...argv,
+        action: 'status',
+        sandboxId: id
+      });
+      break;
+
+    case 'stop':
+      await sandboxOriginal.handler({
+        ...argv,
+        action: 'stop',
+        sandboxId: id
+      });
+      break;
+
+    case 'attach':
+      // Route to attach command
+      const { handler: attachHandler } = require('./attach');
+      await attachHandler({
+        ...argv,
+        sandboxId: id
+      });
+      break;
+
+    case 'exec':
+    case 'execute':
+      // Extract command arguments from process.argv
+      // This is needed because yargs parses options like -l separately
+      const execRawArgs = process.argv.slice(2); // Skip 'node' and script path
+      const execSandboxIndex = execRawArgs.indexOf('sandbox');
+      const execIndex = execRawArgs.indexOf('exec');
+
+      if (execIndex !== -1) {
+        // Get all arguments after 'exec'
+        const execArgs = execRawArgs.slice(execIndex + 1);
+
+        // Parse --session parameter from exec args
+        let sessionName = null;
+        let commandArgs = [];
+
+        for (let i = 0; i < execArgs.length; i++) {
+          if (execArgs[i] === '--session' && i + 1 < execArgs.length) {
+            sessionName = execArgs[i + 1];
+            i++; // Skip session value
+          } else if (execArgs[i] && !execArgs[i].startsWith('-')) {
+            commandArgs.push(execArgs[i]);
+          }
+        }
+
+        const command = commandArgs.join(' ');
+
+        if (sessionName) {
+          // Auto-create session before running command
+          const sessionHandler = require('./sandbox/session');
+
+          // Try to create session (ignore errors - session may already exist or sandbox may not be running)
+          await sessionHandler.handler({
+            ...argv,
+            subaction: 'create',
+            sandboxId: id,
+            session: sessionName,
+            envEnable: true,
+          }).catch(() => {
+            // Ignore errors from create
+          });
+
+          // Run command in session
+          await sessionHandler.handler({
+            ...argv,
+            subaction: 'run',
+            sandboxId: id,
+            session: sessionName,
+            command: command,
+          });
+        } else {
+          await sandboxOriginal.handler({
+            ...argv,
+            action: 'execute',
+            sandboxId: id,
+            command: command || undefined
+          });
+        }
+      } else {
+        await sandboxOriginal.handler({
+          ...argv,
+          action: 'execute',
+          sandboxId: id
+        });
+      }
+      break;
+
+    case 'upload':
+      await sandboxOriginal.handler({
+        ...argv,
+        action: 'upload',
+        sandboxId: id
+      });
+      break;
+
+    case 'download':
+      await sandboxOriginal.handler({
+        ...argv,
+        action: 'download',
+        sandboxId: id
+      });
+      break;
+
+    case 'history':
+      // History is the same as log history
+      const { handleLogHistory } = require('./log/history');
+      await handleLogHistory({
+        ...argv,
+        sandboxId: id
+      });
+      break;
+
+    case 'log':
+      // Log operations require additional handling
+      const logSubcommand = argv._[argv._.indexOf('log') + 1];
+
+      // Extract additional arguments from process.argv (beyond yargs parsing)
+      const rawArgs = process.argv.slice(2);
+      const sandboxIndex = rawArgs.indexOf('sandbox');
+
+      // Find the log file name (first non-option argument after 'log' or after 'tail')
+      let logFile = null;
+      let foundLog = false;
+      let foundTail = false;
+
+      for (let i = sandboxIndex + 1; i < rawArgs.length; i++) {
+        const arg = rawArgs[i];
+
+        if (arg === 'log') {
+          foundLog = true;
+          continue;
+        }
+
+        if (foundLog && arg === 'tail') {
+          foundTail = true;
+          continue;
+        }
+
+        if (foundTail && !arg.startsWith('-')) {
+          logFile = arg;
+          break;
+        }
+      }
+
+      if (logFile) {
+        argv.logFile = logFile;
+      }
+
+      if (logSubcommand === 'search') {
+        await handleSandboxLogSearch({
+          ...argv,
+          sandboxId: id
+        });
+      } else if (logSubcommand === 'tail') {
+        await handleSandboxLogTail({
+          ...argv,
+          sandboxId: id
+        });
+      } else {
+        console.error(`错误：缺少 log 子命令\n`);
+        console.error(`可用的子命令：`);
+        console.error(`  search  - 搜索日志`);
+        console.error(`  tail    - 实时监控日志\n`);
+        console.error(`使用示例：`);
+        console.error(`  rockcli sandbox ${id} log search -k "error"`);
+        console.error(`  rockcli sandbox ${id} log tail -f\n`);
+        console.error(`查看帮助：`);
+        console.error(`  rockcli sandbox --help`);
+        gracefulExit(1);
+      }
+      break;
+
+    default:
+      console.error(`Unknown command: ${command}`);
+      gracefulExit(1);
+  }
+}
+
+// Export internal functions for testing
+sandboxExports.readSandboxConfig = readSandboxConfig;
+
+// Re-export functions from backup module for backward compatibility
+if (sandboxOriginal.getRemoteFileList) {
+  sandboxExports.getRemoteFileList = sandboxOriginal.getRemoteFileList;
+}
+if (sandboxOriginal.validateAuth) {
+  sandboxExports.validateAuth = sandboxOriginal.validateAuth;
+}