rl-rockcli 0.0.1

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

@@ -0,0 +1,428 @@
+/**
+ * sandbox 命令实现
+ * 开源版 sandbox 命令
+ * 格式: rockcli sandbox <id> <command>
+ */
+
+const { SandboxClient, SandboxConfig, getOpenSourceSandboxConfig } = require('../../sdks/sandbox');
+const fs = require('fs-extra');
+const path = require('path');
+const logger = require('../../utils/logger');
+
+// 配置文件路径
+const CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE, '.rock');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'settings.json');
+
+/**
+ * 读取配置文件
+ */
+function readConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+        }
+    } catch (error) {
+        logger.debug(`Failed to read config: ${error.message}`);
+    }
+    return {};
+}
+
+/**
+ * 获取 API Key（优先级：参数 > 环境变量 > 配置文件）
+ */
+function getApiKey(argv) {
+    return argv.apiKey || process.env.ROCK_API_KEY || readConfig()?.sandbox?.api_key;
+}
+
+/**
+ * 读取 sandbox 配置
+ * 优先级：环境变量 > argv > 配置文件 > 默认值
+ */
+function readSandboxConfig(argv = {}) {
+    const config = readConfig();
+    const sandboxConfig = config?.sandbox || {};
+    const defaults = getOpenSourceSandboxConfig();
+
+    return {
+        // 环境变量优先于 argv（yargs 默认值）
+        base_url: process.env.ROCK_BASE_URL || argv.baseUrl || sandboxConfig.base_url || defaults.baseUrl,
+        api_key: getApiKey(argv),
+    };
+}
+
+/**
+ * 创建 SandboxClient
+ * @param {Object} argv - 命令行参数
+ * @param {Object} options - 可选配置
+ * @param {boolean} options.requireImage - 是否要求 image 参数（默认 true）
+ */
+function createClient(argv, options = {}) {
+    const config = readSandboxConfig(argv);
+    const sdkConfig = new SandboxConfig({
+        baseUrl: config.base_url,
+        xrlAuthorization: config.api_key,
+        image: argv.image,
+        memory: argv.memory,
+        cpus: argv.cpus,
+        startupTimeout: argv.timeout,
+        autoClearSeconds: argv.autoClear,
+        waitForAlive: argv.waitForAlive,
+    });
+
+    return new SandboxClient(sdkConfig, { requireImage: options.requireImage !== false });
+}
+
+/**
+ * sandbox 命令模块
+ * 格式: rockcli sandbox <id> <command>
+ */
+module.exports = {
+    command: 'sandbox [id] [subcommand]',
+    describe: 'Sandbox instance management',
+    builder: (yargs) => {
+        return yargs
+            .positional('id', {
+                describe: 'Sandbox ID (for operations on existing sandbox)',
+                type: 'string',
+            })
+            .positional('subcommand', {
+                describe: 'Sandbox command to perform (status, stop, exec, upload, download, log)',
+                type: 'string',
+            })
+            .option('api-key', {
+                describe: 'API key for authentication',
+                type: 'string',
+            })
+            .option('base-url', {
+                describe: 'Base URL for sandbox service',
+                type: 'string',
+                default: 'http://localhost:8080',
+            })
+            .option('image', {
+                describe: 'Docker image to use (for start)',
+                type: 'string',
+            })
+            .option('memory', {
+                describe: 'Memory limit',
+                type: 'string',
+                default: '8g',
+            })
+            .option('cpus', {
+                describe: 'CPU limit',
+                type: 'number',
+                default: 2.0,
+            })
+            .option('timeout', {
+                describe: 'Startup timeout in seconds',
+                type: 'number',
+                default: 120,
+            })
+            .option('auto-clear', {
+                describe: 'Auto clear time in seconds',
+                type: 'number',
+                default: 300,
+            })
+            .option('wait-for-alive', {
+                describe: 'Wait for sandbox to be alive before returning',
+                type: 'boolean',
+                default: false,
+            })
+            .option('command', {
+                describe: 'Command to execute (for exec)',
+                type: 'string',
+            })
+            .option('file', {
+                describe: 'File path for upload/download',
+                type: 'string',
+            })
+            .option('target-path', {
+                describe: 'Target path for upload',
+                type: 'string',
+            })
+            .option('session', {
+                describe: 'Session name',
+                type: 'string',
+            })
+            .strict(false) // Allow unknown options for subcommands
+            .example([
+                ['$0 sandbox start', 'Start a new sandbox (default: python:3.11)'],
+                ['$0 sandbox start --image node:18', 'Start a new sandbox with custom image'],
+                ['$0 sandbox <id> status', 'Get sandbox status'],
+                ['$0 sandbox <id> stop', 'Stop sandbox'],
+                ['$0 sandbox <id> exec --command "ls -la"', 'Execute command in sandbox'],
+                ['$0 sandbox <id> upload --file ./local.txt --target-path /remote.txt', 'Upload file'],
+            ]);
+    },
+    handler: async (argv) => {
+        try {
+            // Rebuild argv._ from process.argv to preserve all original arguments
+            const rawArgs = process.argv.slice(2);
+            argv._ = rawArgs.filter(arg => !arg.startsWith('-'));
+
+            const id = argv.id;
+            const subcommand = argv.subcommand;
+
+            // 特殊处理：如果 id 是 "start"，则识别为 start 命令
+            if (id === 'start' && !subcommand) {
+                await handleStart(argv);
+                return;
+            }
+
+            // 判断命令格式
+            if (!id) {
+                // 无 ID 参数，检查是否是 start 命令
+                const firstArg = rawArgs[rawArgs.indexOf('sandbox') + 1];
+                if (firstArg === 'start') {
+                    await handleStart(argv);
+                    return;
+                }
+                // 显示帮助
+                console.log('Sandbox commands:');
+                console.log('  rockcli sandbox start                     Start a new sandbox (default: python:3.11)');
+                console.log('  rockcli sandbox start --image <image>     Start a new sandbox with custom image');
+                console.log('  rockcli sandbox <id> status               Get sandbox status');
+                console.log('  rockcli sandbox <id> stop                 Stop sandbox');
+                console.log('  rockcli sandbox <id> exec --command "cmd" Execute command');
+                console.log('  rockcli sandbox <id> upload --file <file> Upload file');
+                console.log('  rockcli sandbox <id> download --file <file> Download file');
+                return;
+            }
+
+            // 有 ID 参数，执行对应的子命令
+            switch (subcommand) {
+                case 'status':
+                    await handleStatus(argv, id);
+                    break;
+                case 'stop':
+                    await handleStop(argv, id);
+                    break;
+                case 'exec':
+                case 'execute':
+                    await handleExec(argv, id);
+                    break;
+                case 'upload':
+                    await handleUpload(argv, id);
+                    break;
+                case 'download':
+                    await handleDownload(argv, id);
+                    break;
+                case 'session':
+                    await handleSession(argv, id);
+                    break;
+                case 'replay':
+                    await handleReplay(argv, id);
+                    break;
+                case 'log':
+                    await handleLog(argv, id);
+                    break;
+                case 'start':
+                    // start 命令不应该有 ID
+                    await handleStart(argv);
+                    break;
+                default:
+                    if (subcommand) {
+                        console.error(`Unknown subcommand: ${subcommand}`);
+                    } else {
+                        console.log(`Sandbox ID: ${id}`);
+                        console.log('Available commands: status, stop, exec, upload, download, log');
+                    }
+                    break;
+            }
+        } catch (error) {
+            logger.error(`Sandbox action failed: ${error.message}`);
+            process.exit(1);
+        }
+    },
+};
+
+/**
+ * 处理 start 命令
+ * 与内网版保持一致：默认镜像通过 getOpenSourceSandboxConfig() 获取
+ */
+async function handleStart(argv) {
+    const { getOpenSourceSandboxConfig } = require('../../sdks/sandbox/config');
+    const defaults = getOpenSourceSandboxConfig();
+    const image = argv.image || defaults.image;
+
+    const client = createClient({ ...argv, image });
+    const result = await client.start();
+
+    console.log('Sandbox started successfully');
+    console.log(`Sandbox ID: ${result.sandboxId}`);
+    console.log(`Image: ${image}`);
+    console.log(`Host: ${result.hostName || result.hostIp || 'N/A'}`);
+    console.log(`Status: ${result.isAlive ? 'ready' : 'starting'}`);
+}
+
+/**
+ * 处理 stop 命令
+ */
+async function handleStop(argv, sandboxId) {
+    if (!sandboxId) {
+        throw new Error('Sandbox ID is required for stop');
+    }
+
+    const client = createClient(argv, { requireImage: false });
+    client._sandboxId = sandboxId;
+    await client.stop();
+
+    console.log(`Sandbox ${sandboxId} stopped successfully`);
+}
+
+/**
+ * 处理 status 命令
+ */
+async function handleStatus(argv, sandboxId) {
+    if (!sandboxId) {
+        throw new Error('Sandbox ID is required for status');
+    }
+
+    const client = createClient(argv, { requireImage: false });
+    client._sandboxId = sandboxId;
+    const status = await client.getStatus();
+
+    console.log(JSON.stringify(status, null, 2));
+}
+
+/**
+ * 处理 exec 命令
+ */
+async function handleExec(argv, sandboxId) {
+    const command = argv.command;
+
+    if (!sandboxId) {
+        throw new Error('Sandbox ID is required for exec');
+    }
+    if (!command) {
+        throw new Error('--command is required for exec');
+    }
+
+    const client = createClient(argv, { requireImage: false });
+    client._sandboxId = sandboxId;
+    const result = await client.execute(command);
+
+    if (result.stdout) console.log(result.stdout);
+    if (result.stderr) console.error(result.stderr);
+    process.exit(result.exit_code || 0);
+}
+
+/**
+ * 处理 upload 命令
+ */
+async function handleUpload(argv, sandboxId) {
+    const localPath = argv.file;
+    const targetPath = argv.targetPath;
+
+    if (!sandboxId || !localPath || !targetPath) {
+        throw new Error('Sandbox ID, --file, and --target-path are required for upload');
+    }
+
+    const client = createClient(argv, { requireImage: false });
+    client._sandboxId = sandboxId;
+    const result = await client.uploadFile(localPath, targetPath);
+
+    if (result.success) {
+        console.log(result.message);
+    } else {
+        throw new Error(result.message);
+    }
+}
+
+/**
+ * 处理 download 命令
+ */
+async function handleDownload(argv, sandboxId) {
+    const filePath = argv.file;
+
+    if (!sandboxId || !filePath) {
+        throw new Error('Sandbox ID and --file are required for download');
+    }
+
+    const client = createClient(argv, { requireImage: false });
+    client._sandboxId = sandboxId;
+    const result = await client.downloadFile(filePath);
+
+    console.log(result.content || JSON.stringify(result, null, 2));
+}
+
+/**
+ * 处理 session 命令
+ */
+async function handleSession(argv, sandboxId) {
+    const sessionName = argv.session || 'default';
+
+    if (!sandboxId) {
+        throw new Error('Sandbox ID is required for session');
+    }
+
+    const client = createClient(argv, { requireImage: false });
+    client._sandboxId = sandboxId;
+
+    // 简化版：创建 session
+    const result = await client.createSession({ session: sessionName });
+    console.log(`Session '${sessionName}' created`);
+}
+
+/**
+ * 处理 replay 命令
+ */
+async function handleReplay(argv, sandboxId) {
+    if (!sandboxId) {
+        throw new Error('Sandbox ID is required for replay');
+    }
+
+    // 从 stdin 读取 JSON
+    const readline = require('readline');
+    const rl = readline.createInterface({
+        input: process.stdin,
+        terminal: false,
+    });
+
+    const requests = [];
+    for await (const line of rl) {
+        try {
+            requests.push(JSON.parse(line));
+        } catch (e) {
+            // 跳过无效行
+        }
+    }
+
+    if (requests.length === 0) {
+        throw new Error('No valid requests found in stdin');
+    }
+
+    const client = createClient(argv, { requireImage: false });
+    client._sandboxId = sandboxId;
+
+    console.log(`Replaying ${requests.length} requests...`);
+
+    for (let i = 0; i < requests.length; i++) {
+        const req = requests[i];
+        console.log(`[${i + 1}/${requests.length}] ${req.method} ${req.uri}`);
+
+        try {
+            const result = await client.makeRequest(req);
+            console.log(`  Status: ${result.status}`);
+        } catch (error) {
+            console.error(`  Error: ${error.message}`);
+        }
+    }
+
+    console.log('Replay completed');
+}
+
+/**
+ * 处理 log 命令
+ */
+async function handleLog(argv, sandboxId) {
+    if (!sandboxId) {
+        throw new Error('Sandbox ID is required for log');
+    }
+    // 日志功能通过 log 命令实现
+    console.log(`Log command for sandbox ${sandboxId}`);
+    console.log('Use: rockcli log search --sandbox-id ' + sandboxId);
+}
+
+// 导出辅助函数
+module.exports.readSandboxConfig = readSandboxConfig;
+module.exports.createClient = createClient;

package/src/core/config/index.js

@@ -0,0 +1,77 @@
+/**
+ * 开源版配置模块
+ * 管理配置文件和环境变量
+ */
+
+const fs = require('fs-extra');
+const path = require('path');
+
+// 配置路径
+const CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '/tmp', '.rock');
+const CONFIG_FILE = path.join(CONFIG_DIR, 'settings.json');
+
+/**
+ * 读取配置文件
+ * @returns {Object} 配置对象
+ */
+function readConfig() {
+    try {
+        if (fs.existsSync(CONFIG_FILE)) {
+            return JSON.parse(fs.readFileSync(CONFIG_FILE, 'utf8'));
+        }
+    } catch (error) {
+        // 忽略错误，返回空配置
+    }
+    return {};
+}
+
+/**
+ * 写入配置文件
+ * @param {Object} config - 配置对象
+ */
+function writeConfig(config) {
+    fs.ensureDirSync(CONFIG_DIR);
+    fs.writeFileSync(CONFIG_FILE, JSON.stringify(config, null, 2));
+}
+
+/**
+ * 获取 API Key
+ * 优先级：参数 > 环境变量 > 配置文件
+ * @param {Object} argv - 命令行参数
+ * @returns {string|null}
+ */
+function getApiKey(argv = {}) {
+    return argv.apiKey || process.env.ROCK_API_KEY || readConfig()?.sandbox?.api_key || null;
+}
+
+/**
+ * 获取 Base URL
+ * 优先级：参数 > 环境变量 > 配置文件 > 默认值
+ * @param {Object} argv - 命令行参数
+ * @returns {string}
+ */
+function getBaseUrl(argv = {}) {
+    return argv.baseUrl || process.env.ROCK_BASE_URL || readConfig()?.sandbox?.base_url || 'http://localhost:8080';
+}
+
+/**
+ * 获取 Sandbox 配置
+ * @param {Object} argv - 命令行参数
+ * @returns {Object}
+ */
+function getSandboxConfig(argv = {}) {
+    return {
+        base_url: getBaseUrl(argv),
+        api_key: getApiKey(argv),
+    };
+}
+
+module.exports = {
+    CONFIG_DIR,
+    CONFIG_FILE,
+    readConfig,
+    writeConfig,
+    getApiKey,
+    getBaseUrl,
+    getSandboxConfig,
+};

package/src/core/display/constants.js

@@ -0,0 +1,59 @@
+/**
+ * 展示层常量定义
+ */
+
+// 默认显示字段（通用字段）
+const DISPLAY_FIELDS = [
+    'timestamp',
+    'time_iso8601',
+    'level',
+    'sandbox_id',
+    'trace_id',
+    'request_id',
+    'method',
+    'url',
+    'status',
+    'message',
+    'event',
+    'content',
+];
+
+// 字段颜色映射（ANSI 颜色代码）
+const FIELD_COLOR_MAP = {
+    // 时间/级别/消息: 高亮
+    timestamp: '\x1b[1;36m',
+    time_iso8601: '\x1b[1;36m',
+    level: '\x1b[1;36m',
+    message: '\x1b[1;36m',
+    // 错误/异常: 红色
+    error: '\x1b[1;31m',
+    exception: '\x1b[1;31m',
+    // 其它常用上下文字段
+    sandbox_id: '\x1b[0;36m',
+    trace_id: '\x1b[0;36m',
+    request_id: '\x1b[0;36m',
+    method: '\x1b[0;36m',
+    url: '\x1b[0;36m',
+    status: '\x1b[0;36m',
+    event: '\x1b[0;36m',
+    content: '\x1b[0;36m',
+};
+
+// 默认字段颜色
+const DEFAULT_FIELD_COLOR = '\x1b[0;90m';
+
+// 需要截断的字段
+const TRUNCATE_FIELDS = ['message', 'content', 'event'];
+
+// ANSI 颜色控制码
+const ANSI_COLORS = {
+    RESET: '\x1b[0m',
+};
+
+module.exports = {
+    DISPLAY_FIELDS,
+    FIELD_COLOR_MAP,
+    DEFAULT_FIELD_COLOR,
+    TRUNCATE_FIELDS,
+    ANSI_COLORS,
+};