rl-rockcli 0.0.2 → 0.0.3

package/utils/sandbox-client.js

@@ -1,419 +0,0 @@
-/**
- * Sandbox Client Adapter
- * 
- * 适配 rl-rock 的 Sandbox 类，提供与原 sdks/sandbox 兼容的 API
- */
-
-const { Sandbox: RlRockSandbox } = require('rl-rock');
-const logger = require('./logger');
-
-/**
- * SandboxConfig 配置类（兼容旧 API）
- */
-class SandboxConfig {
-  constructor(options = {}) {
-    this.image = options.image || 'python:3.11';
-    this.autoClearSeconds = options.autoClearSeconds || 300;
-    this.startupTimeout = options.startupTimeout || 120;
-    this.memory = options.memory || '8g';
-    this.cpus = options.cpus !== undefined ? options.cpus : 2.0;
-    this.baseUrl = options.baseUrl;
-    this.xrlAuthorization = options.xrlAuthorization;
-    this.extraHeaders = options.extraHeaders || {};
-    this.cluster = options.cluster || 'zb';
-    this.namespace = options.namespace || null;
-    this.userId = options.userId || null;
-    this.experimentId = options.experimentId || null;
-    this.waitForAlive = options.waitForAlive !== undefined ? options.waitForAlive : false;
-  }
-
-  validate() {
-    if (!this.baseUrl) {
-      throw new Error('baseUrl is required');
-    }
-    if (!this.image) {
-      throw new Error('image is required');
-    }
-  }
-}
-
-/**
- * SandboxClient - 适配 rl-rock 的 Sandbox 类
- * 
- * 提供与原 sdks/sandbox/client.js 兼容的 API
- */
-class SandboxClient {
-  constructor(config, options = {}) {
-    // 支持 SandboxConfig 实例或普通对象
-    if (config instanceof SandboxConfig) {
-      this._config = config;
-    } else {
-      this._config = new SandboxConfig(config);
-    }
-    this._config.validate();
-
-    // 创建 rl-rock Sandbox 实例（只传递非 null 的参数）
-    // 注意：rl-rock 不自动处理 xrlAuthorization，需要通过 extraHeaders 传递
-    const extraHeaders = {
-      ...this._config.extraHeaders,
-    };
-
-    // 将 xrlAuthorization 添加到 extraHeaders（rl-rock 要求通过 headers 传递）
-    if (this._config.xrlAuthorization) {
-      extraHeaders['XRL-Authorization'] = `Bearer ${this._config.xrlAuthorization}`;
-    }
-
-    const sandboxConfig = {
-      baseUrl: this._config.baseUrl,
-      image: this._config.image,
-      autoClearSeconds: this._config.autoClearSeconds,
-      startupTimeout: this._config.startupTimeout,
-      memory: this._config.memory,
-      cpus: this._config.cpus,
-      cluster: this._config.cluster,
-      extraHeaders,
-    };
-
-    // 只添加非 null 的可选参数（rl-rock 会自动添加到 headers）
-    if (this._config.userId) {
-      sandboxConfig.userId = this._config.userId;
-    }
-    if (this._config.experimentId) {
-      sandboxConfig.experimentId = this._config.experimentId;
-    }
-    if (this._config.namespace) {
-      sandboxConfig.namespace = this._config.namespace;
-    }
-
-    this._sandbox = new RlRockSandbox(sandboxConfig);
-
-    // 兼容旧 API：允许直接设置 sandboxId
-    this._sandboxId = null;
-    this._onLog = options.onLog || null;
-  }
-
-  /**
-   * 兼容旧 API：直接设置 sandboxId
-   */
-  set _sandboxId(value) {
-    this._sandbox.sandboxId = value;
-  }
-
-  get _sandboxId() {
-    return this._sandbox.sandboxId;
-  }
-
-  get sandboxId() {
-    return this._sandbox.getSandboxId();
-  }
-
-  get hostName() {
-    return this._sandbox.getHostName();
-  }
-
-  get hostIp() {
-    return this._sandbox.getHostIp();
-  }
-
-  /**
-   * 公开的 config getter（用于测试和外部访问）
-   */
-  get config() {
-    return this._config;
-  }
-
-  /**
-   * Log a message
-   */
-  _log(level, message) {
-    if (this._onLog) {
-      this._onLog(level, message);
-    } else {
-      logger[level](message);
-    }
-  }
-
-  /**
-   * Start a new sandbox instance
-   */
-  async start() {
-    await this._sandbox.start();
-
-    const sandboxId = this._sandbox.getSandboxId();
-    const hostName = this._sandbox.getHostName();
-    const hostIp = this._sandbox.getHostIp();
-
-    let isAlive = false;
-    if (this._config.waitForAlive) {
-      // Wait for sandbox to be alive
-      await this._waitForAlive();
-      isAlive = true;
-    }
-
-    return {
-      sandboxId,
-      hostName,
-      hostIp,
-      isAlive,
-    };
-  }
-
-  /**
-   * Wait for sandbox to be alive
-   */
-  async _waitForAlive() {
-    const startTime = Date.now();
-    const timeout = this._config.startupTimeout * 1000;
-    const loadingChars = ['⠋', '⠙', '⠹', '⠸', '⠼', '⠴', '⠦', '⠧', '⠇', '⠏'];
-    let loadingIndex = 0;
-    let lastLogTime = 0;
-
-    this._log('info', 'Waiting for sandbox to be ready...');
-
-    while (Date.now() - startTime < timeout) {
-      const status = await this._sandbox.getStatus();
-
-      if (status.isAlive) {
-        this._log('info', `Sandbox is ready (ID: ${this._sandbox.getSandboxId()})`);
-        return;
-      }
-
-      const now = Date.now();
-      if (now - lastLogTime > 3000) {
-        loadingIndex = (loadingIndex + 1) % loadingChars.length;
-        const elapsed = Math.floor((now - startTime) / 1000);
-        this._log('info', `${loadingChars[loadingIndex]} Starting sandbox... (${elapsed}s elapsed)`);
-        lastLogTime = now;
-      }
-
-      await new Promise(resolve => setTimeout(resolve, 3000));
-    }
-
-    throw new Error(`Sandbox did not become alive within ${this._config.startupTimeout}s`);
-  }
-
-  /**
-   * Get sandbox status
-   */
-  async getStatus() {
-    return this._sandbox.getStatus();
-  }
-
-  /**
-   * Check if sandbox is alive
-   */
-  async isAlive() {
-    try {
-      const status = await this.getStatus();
-      return {
-        isAlive: status.isAlive,
-        message: status.hostName || '',
-      };
-    } catch (error) {
-      logger.warn(`Failed to check isAlive: ${error.message}`);
-      throw new Error(`Failed to check isAlive: ${error.message}`);
-    }
-  }
-
-  /**
-   * Execute a command in the sandbox
-   */
-  async execute(command) {
-    let commandArray;
-    if (Array.isArray(command)) {
-      commandArray = command;
-    } else {
-      commandArray = ['sh', '-c', command];
-    }
-
-    const result = await this._sandbox.execute({ command: commandArray });
-
-    return {
-      stdout: result.stdout,
-      stderr: result.stderr,
-      exit_code: result.exitCode,
-    };
-  }
-
-  /**
-   * Stop the sandbox
-   */
-  async stop() {
-    if (!this._sandbox.sandboxId) {
-      logger.warn('No sandbox ID to stop');
-      return;
-    }
-    await this._sandbox.stop();
-    logger.info(`Sandbox ${this._sandbox.sandboxId} stopped successfully`);
-  }
-
-  /**
-   * Create a bash session
-   */
-  async createSession(options = {}) {
-    return this._sandbox.createSession({
-      session: options.session || 'default',
-      startupSource: options.startupSource || [],
-      envEnable: options.envEnable || false,
-      env: options.env,
-      remoteUser: options.remoteUser,
-    });
-  }
-
-  /**
-   * Run a command in a session
-   */
-  async runInSession(action) {
-    const result = await this._sandbox.arun(action.command, {
-      session: action.session || 'default',
-      mode: 'normal',
-      timeout: action.timeout,
-    });
-
-    return {
-      output: result.output || '',
-      exit_code: result.exitCode,
-    };
-  }
-
-  /**
-   * Run a command asynchronously in a session using nohup
-   */
-  async runInSessionAsync(action) {
-    const result = await this._sandbox.arun(action.command, {
-      session: action.session || 'default',
-      mode: 'nohup',
-      waitTimeout: (action.timeout || 3600000) / 1000,
-      waitInterval: (action.pollInterval || 5000) / 1000,
-    });
-
-    return {
-      output: result.output || '',
-      exit_code: result.exitCode || 0,
-      timeout: result.failureReason?.includes('timeout') || false,
-      warning: result.failureReason || null,
-    };
-  }
-
-  /**
-   * Write content to a file
-   */
-  async writeFile(content, path) {
-    const result = await this._sandbox.write_file({ content, path });
-    return {
-      success: result.success,
-      message: result.message,
-    };
-  }
-
-  /**
-   * Read a file (with optional line range)
-   */
-  async readFile(filePath, startLine, endLine) {
-    if (startLine && endLine) {
-      if (startLine < 1 || endLine < startLine) {
-        throw new Error(`Invalid line range: startLine=${startLine}, endLine=${endLine}`);
-      }
-      if (endLine - startLine > 1000) {
-        throw new Error(`Line range too large: ${endLine - startLine} lines (max 1000)`);
-      }
-
-      const command = `sed -n ${startLine},${endLine}p ${filePath}`;
-      const result = await this.execute(command);
-
-      if (result.exit_code !== 0) {
-        throw new Error(`Failed to read file ${filePath}: ${result.stderr}`);
-      }
-
-      return { content: result.stdout };
-    }
-
-    // No line range, use read_file directly
-    const result = await this._sandbox.read_file({ path: filePath });
-    return { content: result.content };
-  }
-
-  /**
-   * Upload a file to the sandbox
-   */
-  async uploadFile(localPath, targetPath) {
-    const result = await this._sandbox.uploadByPath(localPath, targetPath);
-    return result;
-  }
-
-  /**
-   * Download a file from the sandbox
-   */
-  async downloadFile(filePath) {
-    const result = await this._sandbox.read_file({ path: filePath });
-    return result;
-  }
-
-  /**
-   * Close a session
-   */
-  async closeSession(session = 'default') {
-    return this._sandbox.closeSession({ session });
-  }
-
-  /**
-   * Close the sandbox
-   */
-  async close() {
-    await this.stop();
-  }
-
-  /**
-   * Make a generic HTTP request to the sandbox API
-   */
-  async makeRequest(request) {
-    const { method, uri, requestBody, headers } = request;
-    const url = `${this._config.baseUrl}${uri}`;
-
-    const axios = require('axios');
-    const requestHeaders = {
-      'X-Cluster': this._config.cluster,
-      'Content-Type': 'application/json',
-    };
-
-    if (this._config.xrlAuthorization) {
-      requestHeaders['XRL-Authorization'] = `Bearer ${this._config.xrlAuthorization}`;
-    }
-
-    if (this._config.userId) {
-      requestHeaders['X-User-Id'] = this._config.userId;
-    }
-
-    if (this._config.experimentId) {
-      requestHeaders['X-Experiment-Id'] = this._config.experimentId;
-    }
-
-    if (this._config.extraHeaders) {
-      Object.assign(requestHeaders, this._config.extraHeaders);
-    }
-
-    if (headers) {
-      Object.assign(requestHeaders, headers);
-    }
-
-    const axiosConfig = {
-      method: method.toLowerCase(),
-      url,
-      headers: requestHeaders,
-    };
-
-    if (requestBody) {
-      axiosConfig.data = requestBody;
-    }
-
-    const response = await axios(axiosConfig);
-
-    return {
-      data: response.data,
-      headers: response.headers,
-      status: response.status,
-    };
-  }
-}
-
-module.exports = { SandboxClient, SandboxConfig };

package/utils/terminal.js

@@ -1,32 +0,0 @@
-'use strict';
-
-/**
- * 终端工具函数
- * 
- * 提供统一的终端宽度获取和分隔线创建功能
- */
-
-/**
- * 获取终端宽度
- * @param {number} [defaultWidth=80] - 默认宽度（当无法获取终端宽度时使用）
- * @returns {number} 终端宽度
- */
-function getTerminalWidth(defaultWidth = 80) {
-  return process.stdout.columns || defaultWidth;
-}
-
-/**
- * 创建分隔线
- * @param {string} [char='─'] - 分隔线字符
- * @param {number} [width] - 分隔线宽度（默认使用终端宽度）
- * @returns {string} 分隔线字符串
- */
-function createSeparator(char = '─', width = null) {
-  const w = width || getTerminalWidth();
-  return char.repeat(Math.max(1, w));
-}
-
-module.exports = {
-  getTerminalWidth,
-  createSeparator,
-};

package/utils/tips.js

@@ -1,106 +0,0 @@
-'use strict';
-
-/**
- * Tips module - Display helpful tips after command output
- */
-
-const chalk = require('chalk');
-const { CLI_NAME } = require('./cli');
-
-/**
- * Format a tip with consistent styling
- * @param {string} message - The tip message
- * @param {string} command - Optional command to highlight
- * @returns {string} Formatted tip string
- */
-function formatTip(message, command = null) {
-  const prefix = chalk.dim('💡 Tip:');
-  if (command) {
-    return `${prefix} ${message}\n   ${chalk.cyan(command)}`;
-  }
-  return `${prefix} ${message}`;
-}
-
-/**
- * Format a "next step" suggestion
- * @param {string} message - The suggestion message
- * @param {string} command - The command to run
- * @returns {string} Formatted next step string
- */
-function formatNextStep(message, command) {
-  const prefix = chalk.dim('→');
-  return `${prefix} ${message}\n   ${chalk.cyan(command)}`;
-}
-
-/**
- * Print a tip to console
- * @param {string} message - The tip message
- * @param {string} command - Optional command to highlight
- */
-function printTip(message, command = null) {
-  console.log('');
-  console.log(formatTip(message, command));
-}
-
-/**
- * Print a "next step" suggestion to console
- * @param {string} message - The suggestion message
- * @param {string} command - The command to run
- */
-function printNextStep(message, command) {
-  console.log('');
-  console.log(formatNextStep(message, command));
-}
-
-/**
- * Print multiple tips in a box
- * @param {Array<{message: string, command?: string}>} tips - Array of tips
- */
-function printTipsBox(tips) {
-  console.log('');
-  console.log(chalk.dim('─'.repeat(60)));
-  for (const tip of tips) {
-    if (tip.command) {
-      console.log(`  ${tip.message}`);
-      console.log(`  ${chalk.cyan(tip.command)}`);
-    } else {
-      console.log(`  ${tip.message}`);
-    }
-    console.log('');
-  }
-  console.log(chalk.dim('─'.repeat(60)));
-}
-
-/**
- * Common tips for various commands
- */
-const TIPS = {
-  afterStart: (sandboxId) => ({
-    message: 'To connect to this sandbox:',
-    command: `${CLI_NAME} sandbox ${sandboxId} attach`,
-  }),
-
-  afterStop: () => ({
-    message: 'To start a new sandbox:',
-    command: `${CLI_NAME} start`,
-  }),
-
-  afterStatus: (sandboxId) => ({
-    message: 'To connect to this sandbox:',
-    command: `${CLI_NAME} sandbox ${sandboxId} attach`,
-  }),
-
-  afterList: () => ({
-    message: 'To connect to a sandbox:',
-    command: `${CLI_NAME} sandbox <sandbox-id> attach`,
-  }),
-};
-
-module.exports = {
-  formatTip,
-  formatNextStep,
-  printTip,
-  printNextStep,
-  printTipsBox,
-  TIPS,
-};