rl-rockcli 0.0.7 → 0.0.8

package/utils/eagleeye_traceid.js

@@ -1,151 +0,0 @@
-/**
- * EagleEye TraceID 生成器
- *
- * TraceID 格式（共30位）:
- * - IPv4 (8位十六进制): 本地IP对应的十六进制数
- * - 毫秒时间 (13位): 当前时间戳（毫秒）
- * - 顺序号 (4位): 自增计数器，范围 1000~9999
- * - 标志位 (1位): 随机生成，范围 a~f 或 0~9
- * - PID (4位): 进程ID的十六进制表示
- *
- * 示例: 0ab5847914463715406577630e0f56
- */
-
-const os = require('os');
-const process = require('process');
-
-// 顺序号计数器（范围 1000~9999）
-let sequenceCounter = 1000;
-
-/**
- * 获取本地 IPv4 地址并转换为8位十六进制字符串
- * @returns {string} 8位十六进制字符串
- */
-function getLocalIpHex() {
-  const interfaces = os.networkInterfaces();
-
-  for (const name of Object.keys(interfaces)) {
-    for (const iface of interfaces[name]) {
-      // 跳过内部地址和非IPv4地址
-      if (iface.family === 'IPv4' && !iface.internal) {
-        const parts = iface.address.split('.');
-        if (parts.length === 4) {
-          // 将IP的4个部分转换为2位十六进制并拼接
-          return parts
-            .map(part => parseInt(part, 10).toString(16).padStart(2, '0'))
-            .join('')
-            .toLowerCase();
-        }
-      }
-    }
-  }
-
-  // 如果没有找到有效IP，使用回环地址 127.0.0.1
-  return '7f000001';
-}
-
-/**
- * 获取当前毫秒时间戳（13位）
- * @returns {string} 13位时间戳字符串
- */
-function getTimestampMillis() {
-  return Date.now().toString();
-}
-
-/**
- * 获取下一个顺序号（4位，范围 1000~9999）
- * @returns {string} 4位顺序号字符串
- */
-function getSequenceNumber() {
-  const seq = sequenceCounter;
-  // 自增并在达到9999时回绕到1000
-  sequenceCounter = sequenceCounter >= 9999 ? 1000 : sequenceCounter + 1;
-  return seq.toString();
-}
-
-/**
- * 生成随机标志位（1位，范围 a~f 或 0~9）
- * @returns {string} 1位十六进制字符
- */
-function generateFlag() {
-  const chars = '0123456789abcdef';
-  return chars[Math.floor(Math.random() * chars.length)];
-}
-
-/**
- * 获取当前进程ID的4位十六进制表示
- * @returns {string} 4位十六进制PID字符串
- */
-function getPidHex() {
-  return process.pid.toString(16).padStart(4, '0').toLowerCase();
-}
-
-/**
- * 生成 EagleEye TraceID
- *
- * 格式: [IPv4(8)][毫秒时间(13)][顺序号(4)][标志位(1)][PID(4)]
- * 总长度: 30位十六进制字符
- *
- * @returns {string} 30位 EagleEye TraceID
- */
-function generateEagleEyeTraceId() {
-  const ipHex = getLocalIpHex();        // 8位
-  const timestamp = getTimestampMillis(); // 13位
-  const sequence = getSequenceNumber();   // 4位
-  const flag = generateFlag();            // 1位
-  const pidHex = getPidHex();             // 4位
-
-  return `${ipHex}${timestamp}${sequence}${flag}${pidHex}`;
-}
-
-/**
- * 生成 EagleEye RpcID
- *
- * RpcID 用于区别同一个调用链下多个网络调用的顺序和嵌套层次
- * 格式: 0.X1.X2.X3...Xi，Xi 都是非负整数
- * 根节点的 RpcId 固定从 0 开始
- *
- * @param {string} parentRpcId - 父级 RpcID（可选，默认为 '0'）
- * @param {number} index - 当前层级索引（可选，默认为 0）
- * @returns {string} RpcID
- */
-function generateRpcId(parentRpcId = '0', index = 0) {
-  return `${parentRpcId}.${index}`;
-}
-
-/**
- * 创建 HTTP 请求头对象，包含 EagleEye TraceID 和 RpcID
- *
- * @param {Object} options - 配置选项
- * @param {string} options.parentRpcId - 父级 RpcID（用于嵌套调用）
- * @param {number} options.rpcIndex - 当前 RPC 调用索引
- * @param {Object} options.extraHeaders - 额外的请求头
- * @returns {Object} HTTP 请求头对象
- */
-function createEagleEyeHeaders(options = {}) {
-  const {
-    parentRpcId = '0',
-    rpcIndex = 0,
-    extraHeaders = {}
-  } = options;
-
-  const traceId = generateEagleEyeTraceId();
-  const rpcId = generateRpcId(parentRpcId, rpcIndex);
-
-  return {
-    'EagleEye-TraceId': traceId,
-    'EagleEye-RpcId': rpcId,
-    ...extraHeaders
-  };
-}
-
-module.exports = {
-  generateEagleEyeTraceId,
-  generateRpcId,
-  createEagleEyeHeaders,
-  // 内部方法导出（用于测试）
-  _getLocalIpHex: getLocalIpHex,
-  _getSequenceNumber: getSequenceNumber,
-  _generateFlag: generateFlag,
-  _getPidHex: getPidHex
-};

package/utils/envDetector.js

@@ -1,78 +0,0 @@
-const path = require('path');
-const fs = require('fs');
-
-/**
- * 环境检测模块
- * 负责判断当前 CLI 是运行在开发模式还是生产模式
- * 
- * 开发模式：开发者在本地通过 `node <entry-file>` 运行
- * 生产模式：用户通过 npm 全局安装后，通过 `rock-cli` 命令运行
- */
-
-/**
- * 检测是否处于开发模式
- * 
- * 判断逻辑：
- * 1. 通过环境变量 ROCK_CLI_DEV_MODE 强制指定（便于测试和特殊场景）
- * 2. 检查是否从 node_modules 路径运行（npm 安装的包）
- * 3. 检查脚本文件路径是否在 rock-cli 项目目录下（开发环境特征）
- * 
- * @returns {boolean} 如果处于开发模式返回 true，生产模式返回 false
- */
-function isDevMode() {
-    // 1. 环境变量强制指定（最高优先级）
-    const envFlag = process.env.ROCK_CLI_DEV_MODE;
-    if (envFlag !== undefined) {
-        const normalized = envFlag.toLowerCase();
-        return normalized === '1' || normalized === 'true' || normalized === 'yes';
-    }
-
-    // 2. 如果从 npm 全局安装路径运行，肯定是生产模式
-    const scriptPath = process.argv[1] || '';
-    if (scriptPath.includes('node_modules')) {
-        return false;
-    }
-
-    // 3. 检查脚本文件路径是否在 rock-cli 项目目录下
-    // 注意：这里检查的是脚本路径，而不是当前工作目录(cwd)
-    // 这样可以避免用户在项目目录下运行已安装的 rock-cli 时被误判为开发模式
-    const scriptDir = path.dirname(scriptPath);
-    const scriptName = path.basename(scriptPath);
-
-    // 常见的 CLI 入口文件名
-    const commonEntryFiles = ['all.js', 'index.js', 'cli.js', 'main.js'];
-
-    if (commonEntryFiles.includes(scriptName)) {
-        // 检查同目录是否有 package.json，且名称为 @ali/rockcli
-        try {
-            const packageJsonPath = path.join(scriptDir, 'package.json');
-            if (fs.existsSync(packageJsonPath)) {
-                const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
-                if (packageJson.name === '@ali/rockcli') {
-                    return true;
-                }
-            }
-        } catch (e) {
-            // 读取失败，继续
-        }
-    }
-
-    // 4. 默认为生产模式（保守策略）
-    return false;
-}
-
-/**
- * 获取环境模式的描述信息（用于日志和调试）
- * @returns {string} 环境模式描述
- */
-function getEnvModeDescription() {
-    if (isDevMode()) {
-        return 'development';
-    }
-    return 'production';
-}
-
-module.exports = {
-    isDevMode,
-    getEnvModeDescription,
-};

package/utils/execution_logger.js

@@ -1,415 +0,0 @@
-const fs = require('fs-extra');
-const os = require('os');
-const path = require('path');
-const crypto = require('crypto');
-
-const configManager = require('./configManager');
-const pkg = require('../package.json');
-const { isDevMode } = require('./envDetector');
-const HookManager = require('./hook-manager');
-const { createPluginContext } = require('../lib/plugin-context');
-
-/**
- * @typedef {Object} ExecutionContext
- * @property {boolean} initialized
- * @property {boolean} logged
- * @property {string | undefined} traceId
- * @property {string | undefined} userApiKey
- * @property {string | undefined} command
- * @property {string[] | undefined} args
- * @property {string} rockCliVersion
- * @property {string} osInfo
- * @property {Date | undefined} startTime
- * @property {string | undefined} errorMessage
- * @property {string | undefined} errorStack
- */
-
-// 全局执行上下文，用于在进程生命周期内累积信息
-/** @type {ExecutionContext} */
-const executionContext = {
-    initialized: false,
-    logged: false,
-    traceId: undefined,
-    userApiKey: undefined,
-    command: undefined,
-    args: undefined,
-    rockCliVersion: pkg.version,
-    osInfo: `${os.platform()} ${os.release()} ${os.arch()}`,
-    startTime: undefined,
-    errorMessage: undefined,
-    errorStack: undefined
-};
-
-/**
- * 生成符合 OpenTelemetry 规范的 trace id（16 字节 / 32 位十六进制字符串）
- */
-function generateTraceId() {
-    return crypto.randomBytes(16).toString('hex');
-}
-
-// 缓存设备 ID，在同一进程内保持一致
-let cachedDeviceID = null;
-
-const DEVICE_ID_FILE = path.join(os.homedir(), '.rock', 'device_id');
-
-/**
- * 从本地文件读取已生成的设备 ID
- */
-function loadDeviceIdFromFile() {
-    try {
-        if (fs.existsSync(DEVICE_ID_FILE)) {
-            const content = fs.readFileSync(DEVICE_ID_FILE, 'utf8').trim();
-            if (content) {
-                return content;
-            }
-        }
-    } catch (e) {
-        // 读取失败时忽略，后续重新生成
-    }
-    return null;
-}
-
-/**
- * 将设备 ID 持久化到本地文件
- */
-function saveDeviceIdToFile(deviceId) {
-    try {
-        const dir = path.dirname(DEVICE_ID_FILE);
-        fs.ensureDirSync(dir);
-        fs.writeFileSync(DEVICE_ID_FILE, deviceId, 'utf8');
-    } catch (e) {
-        // 写入失败不影响命令执行
-    }
-}
-
-/**
- * 获取本机设备 ID（基于 MAC 地址的不可逆哈希）
- */
-function getDeviceID() {
-    if (cachedDeviceID) {
-        return cachedDeviceID;
-    }
-
-    const cachedFromFile = loadDeviceIdFromFile();
-    if (cachedFromFile) {
-        cachedDeviceID = cachedFromFile;
-        return cachedDeviceID;
-    }
-
-    let rawIdentifier = null;
-
-    try {
-        const networkInterfaces = os.networkInterfaces();
-        for (const name of Object.keys(networkInterfaces)) {
-            const interfaces = networkInterfaces[name];
-            if (!interfaces) continue;
-            for (const iface of interfaces) {
-                // 跳过内部接口和虚拟接口
-                if (!iface.internal && iface.mac && iface.mac !== '00:00:00:00:00:00') {
-                    rawIdentifier = iface.mac.toLowerCase();
-                    break;
-                }
-            }
-            if (rawIdentifier) {
-                break;
-            }
-        }
-    } catch (e) {
-        // 忽略获取失败，使用主机名作为备用标识
-    }
-
-    if (!rawIdentifier) {
-        // 如果没有找到 MAC 地址，使用主机名作为固定标识
-        rawIdentifier = os.hostname();
-    }
-
-    const hash = crypto.createHash('sha256').update(rawIdentifier).digest('hex');
-    cachedDeviceID = hash.substring(0, 32);
-
-    saveDeviceIdToFile(cachedDeviceID);
-
-    return cachedDeviceID;
-}
-
-/**
- * 获取本地 IP 地址
- */
-function getLocalIP() {
-    try {
-        const networkInterfaces = os.networkInterfaces();
-        for (const name of Object.keys(networkInterfaces)) {
-            const interfaces = networkInterfaces[name];
-            if (!interfaces) continue;
-            for (const iface of interfaces) {
-                // 跳过内部接口，优先返回 IPv4
-                if (!iface.internal && iface.family === 'IPv4') {
-                    return iface.address;
-                }
-            }
-        }
-        // 如果没有 IPv4，尝试返回 IPv6
-        for (const name of Object.keys(networkInterfaces)) {
-            const interfaces = networkInterfaces[name];
-            if (!interfaces) continue;
-            for (const iface of interfaces) {
-                if (!iface.internal && iface.family === 'IPv6') {
-                    return iface.address;
-                }
-            }
-        }
-    } catch (e) {
-        // 如果获取失败，返回回环地址
-    }
-    return '127.0.0.1';
-}
-
-/**
- * 获取执行日志文件路径
- * 默认：~/.rock/logs/rock-cli-YYYY-MM-DD.log（每天一个文件）
- * 支持通过环境变量 ROCK_CLI_LOG_FILE 覆盖
- */
-function getLogFilePath() {
-    if (process.env.ROCK_CLI_LOG_FILE) {
-        return process.env.ROCK_CLI_LOG_FILE;
-    }
-
-    // 生成基于当前日期的文件名
-    const today = new Date();
-    const year = today.getFullYear();
-    const month = String(today.getMonth() + 1).padStart(2, '0');
-    const day = String(today.getDate()).padStart(2, '0');
-    const dateStr = `${year}-${month}-${day}`;
-
-    const dir = path.join(os.homedir(), '.rock', 'logs');
-    return path.join(dir, `rock-cli-${dateStr}.log`);
-}
-
-/**
- * 追加写入一条 JSON 日志（每条一行）
- */
-function appendLogEntry(entry) {
-    try {
-        const logFile = getLogFilePath();
-        const logDir = path.dirname(logFile);
-        fs.ensureDirSync(logDir);
-        const line = JSON.stringify(entry);
-        fs.appendFileSync(logFile, line + '\n', 'utf8');
-    } catch (e) {
-        // 日志写入失败不应影响正常命令执行
-        // 这里静默失败，避免循环错误
-    }
-}
-
-/**
- * 初始化当前进程的执行上下文
- */
-function initExecutionContext() {
-    if (executionContext.initialized) {
-        return;
-    }
-
-    executionContext.initialized = true;
-    executionContext.startTime = new Date();
-    executionContext.traceId = generateTraceId();
-
-    // 完整命令行参数（不包含 node 与脚本路径）
-    executionContext.args = process.argv.slice(2);
-    executionContext.command = executionContext.args.join(' ');
-
-    // 尝试从 ~/.rock/settings.json 读取 api_key 作为用户标识
-    try {
-        executionContext.userApiKey = configManager.getSandboxConfig('api_key') || 'unknown';
-    } catch (e) {
-        executionContext.userApiKey = 'unknown';
-    }
-}
-
-/**
- * 根据当前执行上下文构造标准日志结构
- */
-function buildLogEntry(success, exitCode) {
-    const endTime = new Date();
-    const durationMs = executionContext.startTime
-        ? endTime.getTime() - executionContext.startTime.getTime()
-        : null;
-
-    let errorMessage = executionContext.errorMessage;
-    if (!success && !errorMessage) {
-        errorMessage = typeof exitCode === 'number'
-            ? `Process exited with code ${exitCode}`
-            : 'Command execution failed';
-    }
-
-    return {
-        event_type: 'cli_execution',
-        event_version: '1.0',
-        trace_id: executionContext.traceId,
-        user_api_key: executionContext.userApiKey,
-        command: executionContext.command,
-        args: executionContext.args,
-        success,
-        timestamp: endTime.toISOString(),
-        node_version: process.version,
-        os_info: executionContext.osInfo,
-        rock_cli_version: executionContext.rockCliVersion,
-        local_ip: getLocalIP(),
-        device_id: getDeviceID(),
-        error_message: errorMessage,
-        error_stack: executionContext.errorStack || null,
-        duration_ms: durationMs
-    };
-}
-
-/**
- * 记录错误信息（供 yargs fail 及业务代码显式调用）
- */
-function recordError(error, message) {
-    if (message && !executionContext.errorMessage) {
-        executionContext.errorMessage = message;
-    }
-    if (error) {
-        if (error.message && !executionContext.errorMessage) {
-            executionContext.errorMessage = error.message;
-        }
-        if (error.stack) {
-            executionContext.errorStack = error.stack;
-        }
-    }
-}
-
-/**
- * 判断是否禁用本地日志记录
- */
-function isLocalLoggingDisabled() {
-    const flag = process.env.ROCK_CLI_DISABLE_LOCAL_LOGGING;
-    if (!flag) {
-        return false;
-    }
-    const normalized = flag.toLowerCase();
-    return normalized === '1' || normalized === 'true' || normalized === 'yes';
-}
-
-/**
- * 注册全局执行日志采集：
- * - 进程退出时输出一条执行日志
- * - 捕获未处理异常和 Promise 拒绝
- */
-function setupGlobalExecutionLogging() {
-    if (executionContext.initialized) {
-        return;
-    }
-
-    if (isLocalLoggingDisabled()) {
-        executionContext.initialized = true;
-        return;
-    }
-
-    initExecutionContext();
-
-    // 捕获未处理的异常
-    process.on('uncaughtException', (err) => {
-        recordError(err);
-        // 标记非正常退出，但避免在这里写日志，统一在 exit 事件中写
-        process.exitCode = process.exitCode || 1;
-    });
-
-    // 捕获未处理的 Promise 拒绝
-    process.on('unhandledRejection', (reason) => {
-        const error = reason instanceof Error ? reason : new Error(String(reason));
-        recordError(error);
-        process.exitCode = process.exitCode || 1;
-    });
-
-    // 使用 beforeExit 进行日志记录
-    // beforeExit 在事件循环清空但进程还未退出时触发，可以执行异步操作
-    process.on('beforeExit', async (code) => {
-        if (executionContext.logged) {
-            return;
-        }
-        executionContext.logged = true;
-
-        const success = code === 0;
-        const entry = buildLogEntry(success, code);
-
-        // 1. 先写入本地日志文件（同步，确保数据落盘）
-        appendLogEntry(entry);
-
-        // 2. 触发 pre-exit 钩子（传递 executionContext 供插件使用）
-        //    注意：此时本地日志已写入，插件可以安全执行远程上报
-        try {
-            const hookManager = HookManager.getInstance();
-            if (hookManager) {
-                const exitContext = createPluginContext({
-                    reason: code === 0 ? 'normal' : 'error',
-                    error: code !== 0 ? new Error(`Exit code: ${code}`) : undefined,
-                    executionContext: entry
-                });
-                await hookManager.executeHooks('pre-exit', exitContext);
-            }
-        } catch (error) {
-            // 钩子执行失败不影响退出
-        }
-
-        process.exit(code);
-    });
-
-    // exit 事件作为兜底（如果 beforeExit 未触发）
-    process.on('exit', (code) => {
-        if (!executionContext.logged) {
-            executionContext.logged = true;
-            const success = code === 0;
-            const entry = buildLogEntry(success, code);
-            appendLogEntry(entry);
-        }
-    });
-}
-
-/**
- * 优雅退出函数 - 确保在退出前完成日志记录
- * @param {number} code - 退出码
- */
-async function gracefulExit(code = 0) {
-    if (executionContext.logged) {
-        process.exit(code);
-        return;
-    }
-
-    executionContext.logged = true;
-    const success = code === 0;
-    const entry = buildLogEntry(success, code);
-
-    // 1. 先写入本地日志文件（同步，确保数据落盘）
-    appendLogEntry(entry);
-
-    // 2. 触发 pre-exit 钩子（传递 executionContext 供插件使用）
-    //    注意：此时本地日志已写入，插件可以安全执行远程上报
-    try {
-        const hookManager = HookManager.getInstance();
-        if (hookManager) {
-            const exitContext = createPluginContext({
-                reason: code === 0 ? 'normal' : 'error',
-                error: code !== 0 ? new Error(`Exit code: ${code}`) : undefined,
-                executionContext: entry
-            });
-            await hookManager.executeHooks('pre-exit', exitContext);
-        }
-    } catch (error) {
-        // 钩子执行失败不影响退出
-        console.error('Failed to execute pre-exit hooks:', error.message);
-    }
-
-    process.exit(code);
-}
-
-module.exports = {
-    setupGlobalExecutionLogging,
-    recordError,
-    gracefulExit,
-    generateTraceId,
-    getLogFilePath,
-    appendLogEntry,
-    buildLogEntry,
-    getLocalIP,
-    getDeviceID,
-    isLocalLoggingDisabled
-};

package/utils/featureManager.js

@@ -1,68 +0,0 @@
-/**
- * Feature Flags 管理器
- * 根据 ~/.rock/features.json 配置文件控制命令的可见性
- */
-
-const fs = require('fs-extra');
-const path = require('path');
-const os = require('os');
-
-const FEATURES_PATH = path.join(os.homedir(), '.rock', 'features.json');
-
-// 需要 feature flag 控制的命令
-const FEATURE_CONTROLLED_COMMANDS = ['test', 'ray', 'config', 'image', 'log'];
-
-/**
- * 读取 features.json 配置
- * @returns {Object} 配置对象，如果文件不存在或读取失败则返回空对象
- */
-function readFeatures() {
-  try {
-    if (fs.existsSync(FEATURES_PATH)) {
-      return fs.readJsonSync(FEATURES_PATH);
-    }
-  } catch (e) {
-    // 忽略读取错误
-  }
-  return {};
-}
-
-/**
- * 检查命令是否启用（在帮助中可见）
- * @param {string} command - 命令名称
- * @returns {boolean} 如果命令启用则返回 true
- */
-function isCommandEnabled(command) {
-  if (!FEATURE_CONTROLLED_COMMANDS.includes(command)) {
-    return true; // 不受控制的命令始终可见
-  }
-  const features = readFeatures();
-  return features[command] === true;
-}
-
-/**
- * 保存 features.json 配置
- * @param {Object} features - 配置对象
- */
-function saveFeatures(features) {
-  const dir = path.dirname(FEATURES_PATH);
-  fs.ensureDirSync(dir);
-  fs.writeJsonSync(FEATURES_PATH, features, { spaces: 2 });
-}
-
-/**
- * 检查 features.json 文件是否存在
- * @returns {boolean}
- */
-function featuresFileExists() {
-  return fs.existsSync(FEATURES_PATH);
-}
-
-module.exports = {
-  readFeatures,
-  isCommandEnabled,
-  saveFeatures,
-  featuresFileExists,
-  FEATURES_PATH,
-  FEATURE_CONTROLLED_COMMANDS
-};