rl-rockcli 0.0.1

package/src/core/sdks/sandbox/client.js

@@ -0,0 +1,472 @@
+/**
+ * Sandbox Client for managing sandbox environments
+ * 开源版 Sandbox SDK 客户端
+ */
+
+const axios = require('axios');
+const { SandboxConfig } = require('./config');
+const logger = require('../../utils/logger');
+
+/**
+ * Simple HTTP logger for SDK
+ */
+const httpLogger = {
+    logRequest: (method, url, data) => {
+        logger.debug(`[HTTP] ${method} ${url}`);
+        if (data) logger.debug(`[HTTP] Request: ${JSON.stringify(data).substring(0, 200)}`);
+    },
+    logResponse: (method, url, status, duration, data, traceId) => {
+        logger.debug(`[HTTP] ${method} ${url} - ${status} (${duration}ms)`);
+        if (traceId) logger.debug(`[HTTP] TraceId: ${traceId}`);
+    },
+    logError: (method, url, error, duration, traceId) => {
+        logger.error(`[HTTP] ${method} ${url} - Error: ${error.message} (${duration}ms)`);
+    }
+};
+
+/**
+ * Sandbox Client for managing sandbox environments
+ */
+class SandboxClient {
+    constructor(config, options = {}) {
+        if (config instanceof SandboxConfig) {
+            this.config = config;
+        } else {
+            this.config = new SandboxConfig(config);
+        }
+        this.config.validate({ requireImage: options.requireImage !== false });
+
+        this._sandboxId = null;
+        this._hostName = null;
+        this._hostIp = null;
+        this._url = `${this.config.baseUrl}/apis/envs/sandbox/v1`;
+        this._onLog = options.onLog || null;
+
+        // Create axios instance with interceptors for HTTP logging
+        this._axios = axios.create();
+        this._setupInterceptors();
+    }
+
+    _log(level, message) {
+        if (this._onLog) {
+            this._onLog(level, message);
+        } else {
+            logger[level](message);
+        }
+    }
+
+    _setupInterceptors() {
+        this._axios.interceptors.request.use((config) => {
+            config._startTime = Date.now();
+            httpLogger.logRequest(
+                config.method?.toUpperCase() || 'GET',
+                config.url,
+                config.data
+            );
+            return config;
+        });
+
+        this._axios.interceptors.response.use(
+            (response) => {
+                const duration = Date.now() - (response.config._startTime || Date.now());
+                const traceId = this._extractTraceId(response.headers);
+                httpLogger.logResponse(
+                    response.config.method?.toUpperCase() || 'GET',
+                    response.config.url,
+                    response.status,
+                    duration,
+                    response.data,
+                    traceId
+                );
+                return response;
+            },
+            (error) => {
+                const duration = Date.now() - (error.config?._startTime || Date.now());
+                const traceId = error.response ? this._extractTraceId(error.response.headers) : null;
+                httpLogger.logError(
+                    error.config?.method?.toUpperCase() || 'GET',
+                    error.config?.url || 'unknown',
+                    error,
+                    duration,
+                    traceId
+                );
+                return Promise.reject(error);
+            }
+        );
+    }
+
+    _extractTraceId(headers) {
+        if (!headers) return null;
+        const traceIdHeaders = ['x-trace-id', 'x-request-id', 'traceid', 'trace-id', 'request-id'];
+        for (const headerName of traceIdHeaders) {
+            const value = headers[headerName];
+            if (value) return value;
+        }
+        return null;
+    }
+
+    get sandboxId() {
+        return this._sandboxId;
+    }
+
+    get hostName() {
+        return this._hostName;
+    }
+
+    get hostIp() {
+        return this._hostIp;
+    }
+
+    _buildHeaders() {
+        const headers = {
+            'Content-Type': 'application/json',
+        };
+
+        if (this.config.xrlAuthorization) {
+            headers['XRL-Authorization'] = `Bearer ${this.config.xrlAuthorization}`;
+        }
+
+        if (this.config.extraHeaders) {
+            Object.assign(headers, this.config.extraHeaders);
+        }
+
+        return headers;
+    }
+
+    /**
+     * Start a new sandbox instance
+     */
+    async start() {
+        const url = `${this._url}/start_async`;
+        const headers = this._buildHeaders();
+        const data = {
+            image: this.config.image,
+            auto_clear_time: Math.floor(this.config.autoClearSeconds / 60),
+            auto_clear_time_minutes: Math.floor(this.config.autoClearSeconds / 60),
+            startup_timeout: this.config.startupTimeout,
+            memory: this.config.memory,
+            cpus: this.config.cpus,
+        };
+
+        logger.debug(`[Sandbox SDK] POST ${url}`);
+        const response = await this._axios.post(url, data, { headers });
+
+        if (response.data.status !== 'Success') {
+            const error = response.data.result || response.data;
+            throw new Error(`Failed to start sandbox: ${JSON.stringify(error)}`);
+        }
+
+        const result = response.data.result;
+        this._sandboxId = result.sandbox_id;
+        this._hostName = result.host_name;
+        this._hostIp = result.host_ip;
+
+        let isAlive = false;
+        if (this.config.waitForAlive) {
+            await this._waitForAlive();
+            isAlive = true;
+        }
+
+        return {
+            sandboxId: this._sandboxId,
+            hostName: this._hostName,
+            hostIp: this._hostIp,
+            isAlive: isAlive,
+        };
+    }
+
+    async _waitForAlive() {
+        const startTime = Date.now();
+        const timeout = this.config.startupTimeout * 1000;
+
+        this._log('info', 'Waiting for sandbox to be ready...');
+
+        while (Date.now() - startTime < timeout) {
+            const status = await this.getStatus();
+
+            if (status.is_alive) {
+                this._log('info', `Sandbox is ready (ID: ${this._sandboxId})`);
+                return;
+            }
+
+            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() {
+        const url = `${this._url}/get_status?sandbox_id=${this._sandboxId}`;
+        const headers = this._buildHeaders();
+
+        const response = await this._axios.get(url, { headers });
+
+        if (response.data.status !== 'Success') {
+            throw new Error(`Failed to get status: ${JSON.stringify(response.data)}`);
+        }
+
+        return response.data.result;
+    }
+
+    /**
+     * Check if sandbox is alive
+     */
+    async isAlive() {
+        try {
+            const status = await this.getStatus();
+            return {
+                isAlive: status.is_alive,
+                message: status.host_name || '',
+            };
+        } catch (error) {
+            throw new Error(`Failed to check isAlive: ${error.message}`);
+        }
+    }
+
+    /**
+     * Execute a command in the sandbox
+     */
+    async execute(command) {
+        const url = `${this._url}/execute`;
+        const headers = this._buildHeaders();
+
+        let commandArray;
+        if (Array.isArray(command)) {
+            commandArray = command;
+        } else {
+            commandArray = ['sh', '-c', command];
+        }
+
+        const data = {
+            command: commandArray,
+            sandbox_id: this._sandboxId,
+        };
+
+        const response = await this._axios.post(url, data, { headers });
+
+        if (response.data.status !== 'Success') {
+            throw new Error(`Failed to execute command: ${JSON.stringify(response.data)}`);
+        }
+
+        return response.data.result;
+    }
+
+    /**
+     * Stop the sandbox
+     */
+    async stop() {
+        if (!this._sandboxId) {
+            logger.warn('No sandbox ID to stop');
+            return;
+        }
+
+        try {
+            const url = `${this._url}/stop`;
+            const headers = this._buildHeaders();
+            const data = { sandbox_id: this._sandboxId };
+
+            await this._axios.post(url, data, { headers });
+            logger.info(`Sandbox ${this._sandboxId} stopped successfully`);
+        } catch (error) {
+            logger.warn(`Failed to stop sandbox: ${error.message}`);
+        }
+    }
+
+    /**
+     * Create a bash session
+     */
+    async createSession(options = {}) {
+        const url = `${this._url}/create_session`;
+        const headers = this._buildHeaders();
+
+        const data = {
+            sandbox_id: this._sandboxId,
+            session: options.session || 'default',
+            session_type: options.sessionType || 'bash',
+            startup_source: options.startupSource || [],
+            env_enable: options.envEnable || false,
+        };
+
+        const response = await this._axios.post(url, data, { headers });
+
+        if (response.data.status !== 'Success') {
+            throw new Error(`Failed to create session: ${JSON.stringify(response.data)}`);
+        }
+
+        return response.data.result;
+    }
+
+    /**
+     * Run a command in a session
+     */
+    async runInSession(action) {
+        const url = `${this._url}/run_in_session`;
+        const headers = this._buildHeaders();
+
+        const data = {
+            sandbox_id: this._sandboxId,
+            command: action.command,
+            session: action.session || 'default',
+            timeout: action.timeout || null,
+            is_interactive_command: action.isInteractiveCommand || false,
+            check: action.check || 'raise',
+        };
+
+        const axiosConfig = { headers };
+
+        if (action.axiosTimeout) {
+            axiosConfig.timeout = action.axiosTimeout;
+        } else if (action.timeout) {
+            axiosConfig.timeout = action.timeout * 1000;
+        }
+
+        if (action.signal) {
+            axiosConfig.signal = action.signal;
+        }
+
+        const response = await this._axios.post(url, data, axiosConfig);
+
+        if (response.data.status !== 'Success') {
+            throw new Error(`Failed to run in session: ${JSON.stringify(response.data)}`);
+        }
+
+        return response.data.result;
+    }
+
+    /**
+     * Close a session
+     */
+    async closeSession(session = 'default') {
+        const url = `${this._url}/close_session`;
+        const headers = this._buildHeaders();
+
+        const data = {
+            sandbox_id: this._sandboxId,
+            session: session,
+        };
+
+        const response = await this._axios.post(url, data, { headers });
+
+        if (response.data.status !== 'Success') {
+            throw new Error(`Failed to close session: ${JSON.stringify(response.data)}`);
+        }
+
+        return response.data.result;
+    }
+
+    /**
+     * Upload a file to the sandbox
+     */
+    async uploadFile(localPath, targetPath) {
+        const fs = require('fs');
+        const path = require('path');
+
+        try {
+            if (!fs.existsSync(localPath)) {
+                return { success: false, message: `File not found: ${localPath}` };
+            }
+
+            const url = `${this._url}/upload`;
+            const headers = this._buildHeaders();
+            delete headers['Content-Type'];
+
+            const form = new FormData();
+            const fileBuffer = fs.readFileSync(localPath);
+            const blob = new Blob([fileBuffer], { type: 'application/octet-stream' });
+
+            form.append('file', blob, path.basename(localPath));
+            form.append('target_path', targetPath);
+            form.append('sandbox_id', this._sandboxId);
+            form.append('container_name', this._sandboxId);
+
+            const response = await fetch(url, {
+                method: 'POST',
+                headers,
+                body: form,
+            });
+
+            const data = await response.json();
+
+            if (data.status !== 'Success') {
+                return { success: false, message: `Failed to upload file: ${JSON.stringify(data)}` };
+            }
+
+            return { success: true, message: `Successfully uploaded ${path.basename(localPath)} to ${targetPath}` };
+        } catch (error) {
+            return { success: false, message: `Upload failed: ${error.message}` };
+        }
+    }
+
+    /**
+     * Download a file from the sandbox
+     */
+    async downloadFile(filePath) {
+        const url = `${this._url}/read_file`;
+        const headers = this._buildHeaders();
+
+        const data = {
+            path: filePath,
+            sandbox_id: this._sandboxId,
+        };
+
+        const response = await this._axios.post(url, data, { headers });
+
+        if (response.data.status !== 'Success') {
+            throw new Error(`Failed to download file: ${JSON.stringify(response.data)}`);
+        }
+
+        return response.data.result;
+    }
+
+    /**
+     * Write content to a file in the sandbox
+     */
+    async writeFile(content, path) {
+        const url = `${this._url}/write_file`;
+        const headers = this._buildHeaders();
+
+        const data = {
+            content,
+            path,
+            sandbox_id: this._sandboxId,
+        };
+
+        const response = await this._axios.post(url, data, { headers });
+
+        if (response.data.status !== 'Success') {
+            return { success: false, message: `Failed to write file ${path}` };
+        }
+
+        return { success: true, message: `Successfully wrote content to file ${path}` };
+    }
+
+    /**
+     * Read a file from the sandbox
+     */
+    async readFile(filePath, startLine, endLine) {
+        if (startLine < 1 || endLine < startLine) {
+            throw new Error(`Invalid line range: startLine=${startLine}, endLine=${endLine}`);
+        }
+
+        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 };
+    }
+
+    /**
+     * Close the sandbox
+     */
+    async close() {
+        await this.stop();
+    }
+}
+
+module.exports = { SandboxClient };

package/src/core/sdks/sandbox/config.js

@@ -0,0 +1,57 @@
+/**
+ * Sandbox SDK Configuration
+ * 开源版配置 - 默认 localhost:8080，支持环境变量配置
+ */
+
+// 开源版默认镜像（不放在配置文件中，直接定义常量）
+const DEFAULT_IMAGE = 'python:3.11';
+
+/**
+ * Sandbox configuration class
+ * 开源版配置类 - 不包含环境特定的默认值
+ */
+class SandboxConfig {
+    constructor(options = {}) {
+        // Technical defaults (not environment-specific)
+        this.autoClearSeconds = options.autoClearSeconds || 300; // 5 minutes
+        this.startupTimeout = options.startupTimeout || 120; // 2 minutes
+        this.memory = options.memory || '8g';
+        this.cpus = options.cpus !== undefined ? options.cpus : 2.0;
+
+        // Environment-specific settings (no defaults, must be provided)
+        this.baseUrl = options.baseUrl || process.env.ROCK_BASE_URL || 'http://localhost:8080';
+        this.xrlAuthorization = options.xrlAuthorization || process.env.ROCK_API_KEY;
+        this.image = options.image;
+        this.cluster = options.cluster;
+        this.namespace = options.namespace || null;
+        this.userId = options.userId || null;
+        this.experimentId = options.experimentId || null;
+        this.extraHeaders = options.extraHeaders || {};
+        this.waitForAlive = options.waitForAlive !== undefined ? options.waitForAlive : false;
+    }
+
+    validate(options = {}) {
+        const { requireImage = true } = options;
+
+        if (!this.baseUrl) {
+            throw new Error('baseUrl is required');
+        }
+        if (requireImage && !this.image) {
+            throw new Error('image is required');
+        }
+    }
+}
+
+/**
+ * Get sandbox configuration for opensource version
+ * 开源版配置获取函数 - 返回开源版默认值
+ * @returns {Object} Sandbox config with default values
+ */
+function getOpenSourceSandboxConfig() {
+    return {
+        baseUrl: process.env.ROCK_BASE_URL || 'http://localhost:8080',
+        image: DEFAULT_IMAGE,
+    };
+}
+
+module.exports = { SandboxConfig, getOpenSourceSandboxConfig, DEFAULT_IMAGE };

package/src/core/sdks/sandbox/index.js

@@ -0,0 +1,13 @@
+/**
+ * Sandbox SDK
+ * 开源版 Sandbox SDK 入口
+ */
+
+const { SandboxConfig, getOpenSourceSandboxConfig } = require('./config');
+const { SandboxClient } = require('./client');
+
+module.exports = {
+    SandboxConfig,
+    SandboxClient,
+    getOpenSourceSandboxConfig,
+};

package/src/core/sdks/sandbox/types.js

@@ -0,0 +1,5 @@
+/**
+ * Sandbox SDK Response Types
+ */
+
+module.exports = {};

package/src/core/utils/index.js

@@ -0,0 +1,9 @@
+/**
+ * 工具函数导出
+ */
+
+const { parseTime } = require('./time');
+
+module.exports = {
+    parseTime,
+};

package/src/core/utils/logger.js

@@ -0,0 +1,106 @@
+/**
+ * 日志工具模块
+ * 基于 winston 实现，支持通过 verbose 级别控制日志输出
+ */
+
+const winston = require('winston');
+
+// 日志级别枚举
+const LogLevel = {
+    ERROR: 0,
+    WARNING: 1,
+    INFO: 2,
+    DEBUG: 3
+};
+
+// 默认 verbose 级别 (0 = 只输出 error)
+let verboseLevel = 0;
+
+// TUI 模式标志：当启用时，抑制所有日志输出以避免干扰 TUI 渲染
+let tuiModeEnabled = false;
+
+// 创建 winston logger 实例
+const logger = winston.createLogger({
+    levels: {
+        error: 0,
+        warn: 1,
+        info: 2,
+        debug: 3
+    },
+    transports: [
+        new winston.transports.Console({
+            stderrLevels: ['error', 'warn'],
+            consoleWarnLevels: ['warn'],
+            format: winston.format.combine(
+                winston.format.printf(({ level, message, ...meta }) => {
+                    const metaStr = Object.keys(meta).length > 0 ? ` ${JSON.stringify(meta)}` : '';
+                    return `${message}${metaStr}`;
+                })
+            )
+        })
+    ]
+});
+
+// 初始设置为 info 级别
+logger.level = 'info';
+
+function setVerboseLevel(level) {
+    verboseLevel = Math.min(Math.max(level, 0), 3);
+    const levelMap = ['info', 'info', 'debug', 'debug'];
+    logger.level = levelMap[verboseLevel];
+}
+
+function getVerboseLevel() {
+    return verboseLevel;
+}
+
+function shouldLog(level) {
+    return level <= verboseLevel;
+}
+
+function setTUIMode(enabled) {
+    tuiModeEnabled = !!enabled;
+}
+
+function getTUIMode() {
+    return tuiModeEnabled;
+}
+
+function error(...args) {
+    if (tuiModeEnabled) return;
+    logger.error(args.join(' '));
+}
+
+function warn(...args) {
+    if (tuiModeEnabled) return;
+    logger.warn(args.join(' '));
+}
+
+function info(...args) {
+    if (tuiModeEnabled) return;
+    logger.info(args.join(' '));
+}
+
+function debug(...args) {
+    if (tuiModeEnabled) return;
+    logger.debug(args.join(' '));
+}
+
+function parseVerboseLevel(argv) {
+    const vCount = argv.v || 0;
+    return Math.min(vCount, 3);
+}
+
+module.exports = {
+    LogLevel,
+    setVerboseLevel,
+    getVerboseLevel,
+    shouldLog,
+    error,
+    warn,
+    info,
+    debug,
+    parseVerboseLevel,
+    setTUIMode,
+    getTUIMode
+};