rl-rockcli 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 ROCK CLI Contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/bin/rockcli.js

@@ -0,0 +1,40 @@
+#!/usr/bin/env node
+
+/**
+ * rockcli 入口脚本
+ * 开源版 CLI Shell，负责加载 core + 指定插件集合
+ */
+
+const yargsFactory = require('yargs/yargs');
+const { hideBin } = require('yargs/helpers');
+
+// 加载 Core 命令
+const logCommand = require('../src/core/commands/log');
+const sandboxCommand = require('../src/core/commands/sandbox');
+const attachCommand = require('../src/core/commands/attach');
+
+function main(argv = process.argv) {
+    const yargs = yargsFactory(hideBin(argv));
+
+    yargs
+        .scriptName('rockcli')
+        .usage('$0 <command> [options]')
+        // 注册命令
+        .command(logCommand)
+        .command(sandboxCommand)
+        .command(attachCommand)
+        .demandCommand(1, 'Please provide a command, e.g.: log search, sandbox start')
+        .strict()
+        .help()
+        .alias('h', 'help')
+        .wrap(Math.min(120, yargs.terminalWidth ? yargs.terminalWidth() : 100))
+        .parse();
+}
+
+if (require.main === module) {
+    main();
+}
+
+module.exports = {
+    main,
+};

package/package.json

@@ -0,0 +1,62 @@
+{
+    "name": "rl-rockcli",
+    "version": "0.0.1",
+    "description": "Open source ROCK CLI - Sandbox and Log management tool",
+    "main": "src/core/index.js",
+    "bin": {
+        "rockcli": "bin/rockcli.js"
+    },
+    "scripts": {
+        "start": "node bin/rockcli.js",
+        "test": "jest --testPathIgnorePatterns=integration",
+        "test:coverage": "jest --coverage --testPathIgnorePatterns=integration",
+        "test:integration": "jest --testPathPattern=integration",
+        "test:all": "jest",
+        "prepublishOnly": "npm test",
+        "prepack": "echo 'Preparing package...'",
+        "publish:dry": "npm pack --dry-run",
+        "publish:check": "bash scripts/prepublish-check.sh",
+        "release": "bash scripts/publish.sh",
+        "release:alpha": "bash scripts/publish.sh prerelease --preid=alpha",
+        "release:beta": "bash scripts/publish.sh prerelease --preid=beta"
+    },
+    "files": [
+        "bin/",
+        "src/core/",
+        "src/plugins/"
+    ],
+    "keywords": [
+        "cli",
+        "rock",
+        "sandbox",
+        "logs",
+        "developer-tools"
+    ],
+    "author": "",
+    "license": "MIT",
+    "dependencies": {
+        "@opentui/core": "^0.1.77",
+        "@opentui/solid": "^0.1.77",
+        "axios": "^1.6.0",
+        "clipboardy": "^5.2.0",
+        "fs-extra": "^11.1.1",
+        "ink": "npm:@jrichman/ink@6.4.8",
+        "logfmt": "^1.4.0",
+        "react": "^19.0.0",
+        "solid-js": "^1.9.0",
+        "winston": "^3.19.0",
+        "yargs": "^17.7.2"
+    },
+    "devDependencies": {
+        "@babel/core": "^7.29.0",
+        "@babel/preset-react": "^7.28.5",
+        "jest": "^29.7.0"
+    },
+    "engines": {
+        "node": ">=14.0.0"
+    },
+    "repository": {
+        "type": "git",
+        "url": "https://github.com/rock-cli/rockcli.git"
+    }
+}

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

@@ -0,0 +1,242 @@
+/**
+ * attach 命令实现
+ * 开源版 attach 命令 - 交互式 REPL
+ */
+
+const { SandboxClient, SandboxConfig } = require('../../sdks/sandbox');
+const logger = require('../../utils/logger');
+const fs = require('fs-extra');
+const path = require('path');
+const readline = require('readline');
+
+// 配置路径
+const CONFIG_DIR = path.join(process.env.HOME || process.env.USERPROFILE || '/tmp', '.rock');
+const HISTORY_DIR = path.join(CONFIG_DIR, 'history');
+
+/**
+ * 内置命令列表
+ */
+const BUILTIN_COMMANDS = [
+    { name: 'log', description: 'View sandbox logs' },
+    { name: 'upload', description: 'Upload file to sandbox' },
+    { name: 'download', description: 'Download file from sandbox' },
+    { name: 'status', description: 'Show sandbox status' },
+    { name: 'stop', description: 'Stop the sandbox' },
+    { name: 'clear', description: 'Clear terminal screen' },
+    { name: 'help', description: 'Show help message' },
+    { name: 'exit', description: 'Exit the REPL (session kept alive)' },
+    { name: 'close', description: 'Close session and exit' },
+];
+
+/**
+ * attach 命令模块
+ */
+module.exports = {
+    command: 'attach <sandboxId>',
+    describe: 'Attach to a sandbox with interactive REPL',
+    builder: (yargs) => {
+        return yargs
+            .positional('sandboxId', {
+                describe: 'Sandbox ID to attach to',
+                type: 'string',
+            })
+            .option('api-key', {
+                describe: 'API key for authentication',
+                type: 'string',
+            })
+            .option('base-url', {
+                describe: 'Base URL for sandbox service',
+                type: 'string',
+                default: process.env.ROCK_BASE_URL || 'http://localhost:8080',
+            })
+            .option('ui', {
+                describe: 'UI mode (basic/opentui)',
+                type: 'string',
+                default: 'basic',
+            });
+    },
+    handler: async (argv) => {
+        const sandboxId = argv.sandboxId;
+        const apiKey = argv.apiKey || process.env.ROCK_API_KEY;
+        const baseUrl = argv.baseUrl;
+
+        if (!apiKey) {
+            console.error('Error: API key required. Set ROCK_API_KEY env var or use --api-key.');
+            process.exit(1);
+        }
+
+        // 创建客户端 - attach 不需要 image 参数
+        const config = new SandboxConfig({
+            baseUrl: baseUrl,
+            xrlAuthorization: apiKey,
+        });
+
+        const client = new SandboxClient(config, { requireImage: false });
+        client._sandboxId = sandboxId;
+
+        // 检查 sandbox 状态
+        try {
+            const status = await client.getStatus();
+            if (!status.is_alive) {
+                console.error(`Sandbox ${sandboxId} is not alive`);
+                process.exit(1);
+            }
+            console.log(`Connected to sandbox ${sandboxId}`);
+            console.log(`Image: ${status.image || 'N/A'}`);
+            console.log(`Status: alive`);
+            console.log('');
+        } catch (error) {
+            console.error(`Failed to connect to sandbox: ${error.message}`);
+            process.exit(1);
+        }
+
+        // 启动 REPL
+        await startREPL(client, sandboxId);
+    },
+};
+
+/**
+ * 启动 REPL
+ */
+async function startREPL(client, sandboxId) {
+    console.log('Type /help for available commands, or enter shell commands to execute.');
+    console.log('');
+
+    // 创建 session
+    try {
+        await client.createSession({ session: 'default' });
+    } catch (error) {
+        logger.debug(`Session creation: ${error.message}`);
+    }
+
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+        prompt: `rockcli:${sandboxId.slice(0, 8)}> `,
+    });
+
+    rl.prompt();
+
+    rl.on('line', async (input) => {
+        const trimmed = input.trim();
+
+        if (!trimmed) {
+            rl.prompt();
+            return;
+        }
+
+        // 处理内置命令
+        if (trimmed.startsWith('/')) {
+            await handleBuiltinCommand(trimmed, client, sandboxId, rl);
+            rl.prompt();
+            return;
+        }
+
+        // 执行 shell 命令
+        try {
+            const result = await client.execute(trimmed);
+            if (result.stdout) console.log(result.stdout);
+            if (result.stderr) console.error(result.stderr);
+        } catch (error) {
+            console.error(`Error: ${error.message}`);
+        }
+
+        rl.prompt();
+    });
+
+    rl.on('close', () => {
+        console.log('Exiting REPL...');
+        process.exit(0);
+    });
+}
+
+/**
+ * 处理内置命令
+ */
+async function handleBuiltinCommand(cmd, client, sandboxId, rl) {
+    const parts = cmd.slice(1).split(/\s+/);
+    const command = parts[0].toLowerCase();
+    const args = parts.slice(1);
+
+    switch (command) {
+        case 'help':
+            console.log('Available commands:');
+            BUILTIN_COMMANDS.forEach(c => {
+                console.log(`  /${c.name.padEnd(10)} - ${c.description}`);
+            });
+            console.log('');
+            console.log('Or enter any shell command to execute in the sandbox.');
+            break;
+
+        case 'status':
+            try {
+                const status = await client.getStatus();
+                console.log(JSON.stringify(status, null, 2));
+            } catch (error) {
+                console.error(`Error: ${error.message}`);
+            }
+            break;
+
+        case 'log':
+            console.log('Log viewing not implemented in basic mode');
+            break;
+
+        case 'upload':
+            if (args.length < 2) {
+                console.log('Usage: /upload <local-path> <remote-path>');
+            } else {
+                try {
+                    const result = await client.uploadFile(args[0], args[1]);
+                    console.log(result.message);
+                } catch (error) {
+                    console.error(`Error: ${error.message}`);
+                }
+            }
+            break;
+
+        case 'download':
+            if (args.length < 1) {
+                console.log('Usage: /download <remote-path> [local-path]');
+            } else {
+                try {
+                    const result = await client.downloadFile(args[0]);
+                    console.log(result.content || JSON.stringify(result, null, 2));
+                } catch (error) {
+                    console.error(`Error: ${error.message}`);
+                }
+            }
+            break;
+
+        case 'stop':
+            try {
+                await client.stop();
+                console.log(`Sandbox ${sandboxId} stopped`);
+                rl.close();
+            } catch (error) {
+                console.error(`Error: ${error.message}`);
+            }
+            break;
+
+        case 'clear':
+            console.clear();
+            break;
+
+        case 'exit':
+            console.log('Exiting REPL (sandbox remains running)');
+            rl.close();
+            break;
+
+        case 'close':
+            try {
+                await client.closeSession('default');
+            } catch (error) {
+                // 忽略错误
+            }
+            console.log('Session closed');
+            rl.close();
+            break;
+
+        default:
+            console.log(`Unknown command: /${command}. Type /help for available commands.`);
+    }
+}

package/src/core/commands/log/constants.js

@@ -0,0 +1,20 @@
+/**
+ * log 命令常量
+ * 复用 display 层的常量定义
+ */
+
+const {
+    DISPLAY_FIELDS,
+    FIELD_COLOR_MAP,
+    DEFAULT_FIELD_COLOR,
+    TRUNCATE_FIELDS,
+    ANSI_COLORS,
+} = require('../../display/constants');
+
+module.exports = {
+    DISPLAY_FIELDS,
+    FIELD_COLOR_MAP,
+    DEFAULT_FIELD_COLOR,
+    TRUNCATE_FIELDS,
+    ANSI_COLORS,
+};

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

@@ -0,0 +1,94 @@
+/**
+ * log 命令入口
+ */
+
+const { handleLogSearch } = require('./search');
+
+/**
+ * log 命令定义（yargs 格式）
+ */
+module.exports = {
+    command: 'log <action>',
+    describe: 'Log operations (currently only supports "search" on local log files)',
+    builder: (yargs) => {
+        return yargs
+            .positional('action', {
+                describe: 'Log action to perform',
+                type: 'string',
+                choices: ['search'],
+            })
+            .option('keyword', {
+                alias: 'k',
+                describe: 'Search keyword (space-separated keywords will be ANDed)',
+                type: 'string',
+            })
+            .option('minutes', {
+                alias: 'm',
+                describe: 'Search logs from last N minutes',
+                type: 'number',
+                group: 'Time Range:',
+            })
+            .option('start-time', {
+                describe: 'Start time (timestamp, relative time like "15m", "1h", or date string)',
+                type: 'string',
+                group: 'Time Range:',
+            })
+            .option('end-time', {
+                describe: 'End time (same format as start-time, defaults to now when omitted)',
+                type: 'string',
+                group: 'Time Range:',
+            })
+            .option('limit', {
+                alias: 'l',
+                describe: 'Max number of logs to return',
+                type: 'number',
+                default: 100,
+            })
+            .option('offset', {
+                alias: 'o',
+                describe: 'Number of logs to skip before returning results',
+                type: 'number',
+                default: 0,
+            })
+            .option('log-format', {
+                describe: 'Output format: logfmt or json',
+                type: 'string',
+                default: 'logfmt',
+            })
+            .option('columns', {
+                describe: 'Comma-separated list of fields to display',
+                type: 'string',
+            })
+            .option('truncate', {
+                describe: 'Truncate long field values (0 to disable)',
+                type: 'number',
+                default: 2048,
+            })
+            .option('highlight', {
+                describe: 'Enable keyword highlight in values',
+                type: 'boolean',
+                default: true,
+            })
+            .option('sandbox-id', {
+                describe: 'Filter logs by sandbox_id field',
+                type: 'string',
+            })
+            .option('event', {
+                describe: 'Filter logs by event field',
+                type: 'string',
+            })
+            .example([
+                ['$0 log search -m 15 -k "error"', 'Search local CLI logs in last 15 minutes with keyword "error"'],
+            ]);
+    },
+    handler: async (argv) => {
+        const { action } = argv;
+        if (action === 'search') {
+            await handleLogSearch(argv);
+            return;
+        }
+        // eslint-disable-next-line no-console
+        console.error(`Unsupported log action: ${action}`);
+        process.exitCode = 1;
+    },
+};

package/src/core/commands/log/search.js

@@ -0,0 +1,106 @@
+/**
+ * log search 命令实现
+ * 依赖 LogProvider 接口，不依赖具体实现
+ */
+
+const { parseTime } = require('../../utils/time');
+const { displayLogs } = require('../../display/format');
+
+/**
+ * log search 命令处理函数
+ * @param {Object} argv - 命令行参数
+ * @param {Object} provider - LogProvider 实例（注入）
+ */
+async function handleLogSearch(argv, provider = null) {
+    const {
+        keyword,
+        minutes,
+        startTime,
+        endTime,
+        limit = 100,
+        offset = 0,
+        logFormat = 'logfmt',
+        columns,
+        truncate = 2048,
+        highlight = true,
+        sandboxId,
+        event,
+    } = argv;
+
+    let actualStart;
+    let actualEnd;
+
+    if (minutes) {
+        const m = Number(minutes);
+        if (!Number.isFinite(m) || m <= 0) {
+            throw new Error('--minutes 必须是正数');
+        }
+        actualEnd = Date.now();
+        actualStart = actualEnd - m * 60 * 1000;
+    } else {
+        actualStart = parseTime(startTime);
+        actualEnd = endTime ? parseTime(endTime) : Date.now();
+    }
+
+    if (!actualStart) {
+        throw new Error('必须指定 --minutes 或 --start-time');
+    }
+
+    if (actualEnd == null) {
+        actualEnd = Date.now();
+    }
+
+    // 归一化为秒对齐
+    actualStart = Math.floor(actualStart / 1000) * 1000;
+    actualEnd = Math.floor(actualEnd / 1000) * 1000;
+
+    // 使用注入的 provider 或从默认路径创建
+    let client = provider;
+    if (!client) {
+        // 默认使用 file-client（向后兼容）
+        const createFileLogClient = require('../../../plugins/oss-file-log/file-client');
+        client = createFileLogClient();
+    }
+
+    await client.connect();
+
+    // 按接口契约传递所有标准字段（包括 table/orderBy/orderDirection），
+    // 由具体实现决定是否使用（开源 file backend 会忽略 table 等字段）
+    const logs = await client.query({
+        startTime: actualStart,
+        endTime: actualEnd,
+        filter: keyword ? String(keyword) : null,
+        limit,
+        offset,
+        count: false,
+        table: null, // 开源版无 table 概念，传 null
+        orderBy: '@timestamp',
+        orderDirection: 'ASC',
+        sandboxId,
+        event,
+    });
+
+    await client.close();
+
+    let resultLogs = logs || [];
+
+    if (sandboxId) {
+        resultLogs = resultLogs.filter((log) => log && log.sandbox_id === sandboxId);
+    }
+
+    if (event) {
+        resultLogs = resultLogs.filter((log) => log && log.event === event);
+    }
+
+    if (!resultLogs || resultLogs.length === 0) {
+        // eslint-disable-next-line no-console
+        console.log('No logs found. (Check ~/.rock/logs/rock-cli-YYYY-MM-DD.log)');
+        return;
+    }
+
+    displayLogs(resultLogs, false, logFormat, columns, truncate, keyword, highlight);
+}
+
+module.exports = {
+    handleLogSearch,
+};