@dahawa/hawa-cli-analysis 1.0.4

package/logger-manager.js

@@ -0,0 +1,85 @@
+import os from 'os';
+import pino from 'pino';
+import fs from 'fs';
+import path from 'path';
+
+class LogManager {
+  constructor() {
+    this.allLoggers = {};
+  }
+  __createLogger(cliType , full) {
+        //日志打印在用户目录下面
+        let homedir = os.homedir();
+        //在用户目录下创建配置信息和日志输出
+        let   logDir = path.join(homedir, '.hawa-cli-analysis','logs',cliType);
+
+        //如果日志目录不存在进行创建
+        if (!fs.existsSync(logDir)) {
+            fs.mkdirSync(logDir, { recursive: true });
+        }
+
+        //console.log('hawa-cli-analysis log Directory:', logDir);
+
+        // 使用时间戳创建文件，但只在第一次创建时显示
+        let timestamp = Date.now();
+        const filename = full ? `api-full-${timestamp}.log` : `api-simple-${timestamp}.log`;
+        const filepath = path.join(logDir, filename);
+
+        //console.log(`Creating ${full ? 'full' : 'simple'} log file:`, filepath);
+
+        const fd = fs.openSync(filepath, 'a');
+
+        const stream = {
+        write: (str) => {
+            // 每条日志：writeSync -> fsyncSync
+            fs.writeSync(fd, str);
+            fs.fsyncSync(fd);
+        }
+        };
+
+        // 创建 Pino 记录器，并将流作为日志输出目标
+        const logger = pino({
+            level: process.env.LOG_LEVEL || 'debug', // 允许通过环境变量控制
+            base: null,                              // 去掉 pid 和 hostname
+            timestamp: () => {
+            const now = new Date();
+            const yyyy = now.getFullYear();
+            const mm = String(now.getMonth() + 1).padStart(2, '0');
+            const dd = String(now.getDate()).padStart(2, '0');
+            const hh = String(now.getHours()).padStart(2, '0');
+            const mi = String(now.getMinutes()).padStart(2, '0');
+            const ss = String(now.getSeconds()).padStart(2, '0');
+            return `,"time":"${yyyy}-${mm}-${dd} ${hh}:${mi}:${ss}"`;
+            },
+            formatters: {
+            level(label) {
+                return { level: label }; // level 数字改为字符串枚举值
+            },
+            }
+        },stream);
+
+        return logger;
+    
+  }
+  getSystemLogger(){
+    return this.getLogger();
+  }
+  getLogger(cliType, full=true) {
+     if(!this.allLoggers["_system"]){
+         this.allLoggers["_system"] = this.__createLogger("system", false);
+     }
+     if(cliType==null){
+        return this.allLoggers["_system"];
+     }
+     if(!this.allLoggers[cliType]){
+        this.allLoggers[cliType] = {
+            full:this.__createLogger(cliType, full),
+            simple:this.__createLogger(cliType, false),
+            system:this.allLoggers["_system"]
+        }
+     }
+     return this.allLoggers[cliType];
+  }
+}
+
+export default new LogManager();

package/logger.js

@@ -0,0 +1,112 @@
+import os from 'os';
+import pino from 'pino';
+import fs from 'fs';
+import {createStream} from 'rotating-file-stream';
+import {fileURLToPath } from 'url';
+import path from 'path';
+
+//日志打印在用户目录下面
+//const __filename = fileURLToPath(import.meta.url);
+let homedir = os.homedir();
+//在用户目录下创建配置信息和日志输出
+let   logDir = path.join(homedir, '.hawa-cli-analysis','logs');
+
+//如果日志目录不存在进行创建
+if (!fs.existsSync(logDir)) {
+     fs.mkdirSync(logDir, { recursive: true });
+}
+
+//console.log('hawa-cli-analysis log Directory:', logDir);
+
+let timestamp = Date.now();
+
+// 创建一个 rotating-file-stream 实例
+/*
+const stream = createStream(`api-full-${timestamp}.log`, {
+  size: "10M", // 每个日志文件的最大大小
+  interval: "1d", // 每天轮转一次
+  compress: "gzip", // 压缩旧日志文件
+  path: logDir, // 日志文件存放路径
+});
+*/
+/*
+const stream = pino.destination({
+  dest: `${logDir}/api-full-${timestamp}.log`, // 文件路径
+  sync: false, //使用同步写入
+});
+*/
+const fd = fs.openSync(`${logDir}/api-full-${timestamp}.log`, 'a');
+
+const stream = {
+  write: (str) => {
+    // 每条日志：writeSync -> fsyncSync
+    fs.writeSync(fd, str);
+    fs.fsyncSync(fd);
+  }
+};
+
+// 创建 Pino 记录器，并将流作为日志输出目标
+const apiFullLogger = pino({
+    level: process.env.LOG_LEVEL || 'debug', // 允许通过环境变量控制
+    base: null,                              // 去掉 pid 和 hostname
+    timestamp: () => {
+      const now = new Date();
+      const yyyy = now.getFullYear();
+      const mm = String(now.getMonth() + 1).padStart(2, '0');
+      const dd = String(now.getDate()).padStart(2, '0');
+      const hh = String(now.getHours()).padStart(2, '0');
+      const mi = String(now.getMinutes()).padStart(2, '0');
+      const ss = String(now.getSeconds()).padStart(2, '0');
+      return `,"time":"${yyyy}-${mm}-${dd} ${hh}:${mi}:${ss}"`;
+    },
+    formatters: {
+      level(label) {
+        return { level: label }; // level 数字改为字符串枚举值
+      },
+    }
+},stream);
+/** 
+// 创建一个 rotating-file-stream 实例
+const streamSimple = createStream(`api-simple-${timestamp}.log`, {
+  size: "10M", // 每个日志文件的最大大小
+  interval: "1d", // 每天轮转一次
+  compress: "gzip", // 压缩旧日志文件
+  path: logDir, // 日志文件存放路径
+});
+**/
+
+const fdsimple = fs.openSync(`${logDir}/api-simple-${timestamp}.log`, 'a');
+
+const streamSimple = {
+  write: (str) => {
+    // 每条日志：writeSync -> fsyncSync
+    //fs.writeSync(fdsimple, str.replace(/\\n/g, '\n'));
+    fs.writeSync(fdsimple, str);
+    fs.fsyncSync(fdsimple);
+  }
+};
+
+// 创建 Pino 记录器，并将流作为日志输出目标
+export const apiSimpleLogger = pino({
+    level: process.env.LOG_LEVEL || 'debug', // 允许通过环境变量控制
+    base: null,                              // 去掉 pid 和 hostname
+    timestamp: () => {
+      const now = new Date();
+      const yyyy = now.getFullYear();
+      const mm = String(now.getMonth() + 1).padStart(2, '0');
+      const dd = String(now.getDate()).padStart(2, '0');
+      const hh = String(now.getHours()).padStart(2, '0');
+      const mi = String(now.getMinutes()).padStart(2, '0');
+      const ss = String(now.getSeconds()).padStart(2, '0');
+      return `,"time":"${yyyy}-${mm}-${dd} ${hh}:${mi}:${ss}"`;
+    },
+    formatters: {
+      level(label) {
+        return { level: label }; // level 数字改为字符串枚举值
+      },
+    }
+},streamSimple);
+
+
+
+export default apiFullLogger;

package/mcp/claude-mcpproxy-launcher.js

@@ -0,0 +1,5 @@
+import {startMCPServerProxy} from "../codex/mcpserver.js"
+
+startMCPServerProxy();
+
+process.stdout.write("ok_ok\n");

package/mcp_oauth_tokens.js

@@ -0,0 +1,40 @@
+{
+  "meta|https://radar.mcp.cloudflare.com": {
+    "issuer": "https://radar.mcp.cloudflare.com",
+    "authorization_endpoint": "https://radar.mcp.cloudflare.com/oauth/authorize",
+    "token_endpoint": "https://radar.mcp.cloudflare.com/token",
+    "registration_endpoint": "https://radar.mcp.cloudflare.com/register",
+    "response_types_supported": [
+      "code"
+    ],
+    "response_modes_supported": [
+      "query"
+    ],
+    "grant_types_supported": [
+      "authorization_code",
+      "refresh_token"
+    ],
+    "token_endpoint_auth_methods_supported": [
+      "client_secret_basic",
+      "client_secret_post",
+      "none"
+    ],
+    "revocation_endpoint": "https://radar.mcp.cloudflare.com/token",
+    "code_challenge_methods_supported": [
+      "plain",
+      "S256"
+    ]
+  },
+  "reg|https://radar.mcp.cloudflare.com|http://127.0.0.1:53175/callback": {
+    "client_id": "ZCV41vccvgvhNsEh",
+    "obtained_at": 1759938844949
+  },
+  "tokens|https://radar.mcp.cloudflare.com|ZCV41vccvgvhNsEh": {
+    "access_token": "bab2be0cfaea55f79aefd9d5c9b4cc04:S5OyKXATKP6YduMh:It8GB9SBrgrcvzf7nGU6D2xUi0WYjqKF",
+    "token_type": "bearer",
+    "expires_in": 3600,
+    "refresh_token": "bab2be0cfaea55f79aefd9d5c9b4cc04:S5OyKXATKP6YduMh:piFV9MdBn22WOLkrssCqa4qkiPPKSPv7",
+    "scope": "user:read offline_access account:read radar:read url_scanner:write",
+    "expires_at": 1759942473010
+  }
+}

package/package.json

@@ -0,0 +1,36 @@
+{
+  "name": "@dahawa/hawa-cli-analysis",
+  "version": "1.0.4",
+  "main": "index",
+  "bin": {
+    "uclaude": "uclaude.js",
+    "ucodex": "ucodex.js"
+  },
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1"
+  },
+  "type": "module",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/jiweigang1/hawa-cli-analysis.git"
+  },
+  "author": "",
+  "license": "MIT",
+  "bugs": {
+    "url": "https://github.com/jiweigang1/hawa-cli-analysis/issues"
+  },
+  "homepage": "https://github.com/jiweigang1/hawa-cli-analysis#readme",
+  "description": "",
+  "dependencies": {
+    "@anthropic-ai/sdk": "^0.62.0",
+    "@iarna/toml": "^2.2.5",
+    "@modelcontextprotocol/sdk": "^1.19.1",
+    "fastify": "^5.6.1",
+    "inquirer": "^12.9.6",
+    "pino": "^9.9.5",
+    "ps-list": "^9.0.0",
+    "ps-tree": "^1.2.0",
+    "rotating-file-stream": "^3.2.7",
+    "uuid": "^13.0.0"
+  }
+}

package/port-manager.js

@@ -0,0 +1,80 @@
+import net from 'net';
+
+/**
+ * 端口管理器
+ * 用于动态分配可用端口
+ */
+class PortManager {
+    constructor() {
+        this.allocatedPorts = new Set();
+        this.startPort = 3000;
+        this.maxPort = 3999;
+    }
+
+    /**
+     * 检查端口是否可用
+     * @param {number} port - 要检查的端口
+     * @returns {Promise<boolean>} - 端口是否可用
+     */
+    async isPortAvailable(port) {
+        return new Promise((resolve) => {
+            const server = net.createServer();
+
+            server.once('error', (err) => {
+                if (err.code === 'EADDRINUSE') {
+                    resolve(false);
+                } else {
+                    resolve(false);
+                }
+            });
+
+            server.once('listening', () => {
+                server.close();
+                resolve(true);
+            });
+
+            server.listen(port);
+        });
+    }
+
+    /**
+     * 获取一个可用端口
+     * @returns {Promise<number|null>} - 可用端口或null
+     */
+    async getAvailablePort() {
+        for (let port = this.startPort; port <= this.maxPort; port++) {
+            if (this.allocatedPorts.has(port)) {
+                continue;
+            }
+
+            const isAvailable = await this.isPortAvailable(port);
+            if (isAvailable) {
+                this.allocatedPorts.add(port);
+                return port;
+            }
+        }
+
+        return null;
+    }
+
+    /**
+     * 释放端口
+     * @param {number} port - 要释放的端口
+     */
+    releasePort(port) {
+        this.allocatedPorts.delete(port);
+    }
+
+    /**
+     * 获取当前已分配的端口
+     * @returns {Set<number>} - 已分配的端口集合
+     */
+    getAllocatedPorts() {
+        return new Set(this.allocatedPorts);
+    }
+}
+
+// 创建全局单例实例
+const portManager = new PortManager();
+
+export default portManager;

package/simple-transform-example.js

@@ -0,0 +1,213 @@
+// Simple example of using transformResponseIn with streaming data
+import AnthropicTransformer from './anthropic-transformer.js';
+
+// Example streaming response data (like the one you provided)
+const exampleStreamData = [
+  'event: response.created\ndata: {"id":"resp_abc123","type":"response.created","created":1739558401,"response":{"id":"resp_abc123","model":"gpt-4o-mini","status":"in_progress"}}\n\n',
+  'event: response.in_progress\ndata: {"id":"resp_abc123","type":"response.in_progress","response":{"id":"resp_abc123","status":"in_progress"}}\n\n',
+  'event: response.output_text.delta\ndata: {"id":"resp_abc123","type":"response.output_text.delta","response_id":"resp_abc123","output_index":0,"delta":"早"}\n\n',
+  'event: response.output_text.delta\ndata: {"id":"resp_abc123","type":"response.output_text.delta","response_id":"resp_abc123","output_index":0,"delta":"上"}\n\n',
+  'event: response.output_text.delta\ndata: {"id":"resp_abc123","type":"response.output_text.delta","response_id":"resp_abc123","output_index":0,"delta":"好，"}\n\n',
+  'event: response.output_text.delta\ndata: {"id":"resp_abc123","type":"response.output_text.delta","response_id":"resp_abc123","output_index":0,"delta":"给你一段流式返回示例。"}\n\n',
+  'event: response.output_text.done\ndata: {"id":"resp_abc123","type":"response.output_text.done","response_id":"resp_abc123","output_index":0}\n\n'
+];
+
+// Simple method to transform streaming response data
+async function transformResponseIn(streamData) {
+  const transformer = new AnthropicTransformer();
+
+  // Create a mock Response object with a readable stream
+  const stream = new ReadableStream({
+    start(controller) {
+      // Simulate streaming by sending data chunks with delays
+      let index = 0;
+      const encoder = new TextEncoder();
+
+      const sendNextChunk = () => {
+        if (index < streamData.length) {
+          controller.enqueue(encoder.encode(streamData[index]));
+          index++;
+          setTimeout(sendNextChunk, 100); // Simulate network delay
+        } else {
+          controller.close();
+        }
+      };
+
+      sendNextChunk();
+    }
+  });
+
+  // Create a Response object that mimics the actual streaming response
+  const mockResponse = new Response(stream, {
+    headers: {
+      'Content-Type': 'text/event-stream',
+      'Cache-Control': 'no-cache',
+      'Connection': 'keep-alive'
+    }
+  });
+
+  try {
+    // Use the existing transformResponseIn method
+    const transformedResponse = await transformer.transformResponseIn(mockResponse);
+
+    // Process the transformed stream
+    const reader = transformedResponse.body.getReader();
+    const decoder = new TextDecoder();
+
+    console.log('Transformed Anthropic-style streaming response:');
+    console.log('==============================================');
+
+    while (true) {
+      const { done, value } = await reader.read();
+      if (done) break;
+
+      const chunk = decoder.decode(value);
+      const lines = chunk.split('\n');
+
+      for (const line of lines) {
+        if (line.startsWith('event:')) {
+          const eventType = line.replace('event:', '').trim();
+          console.log(`Event: ${eventType}`);
+        } else if (line.startsWith('data:')) {
+          const data = line.replace('data:', '').trim();
+          try {
+            const parsedData = JSON.parse(data);
+            console.log('Data:', JSON.stringify(parsedData, null, 2));
+          } catch (e) {
+            console.log('Data:', data);
+          }
+        }
+      }
+    }
+
+    return transformedResponse;
+  } catch (error) {
+    console.error('Error transforming response:', error);
+    throw error;
+  }
+}
+
+// Even simpler method for direct data transformation
+function simpleTransformResponse(data) {
+  // Convert the streaming data to Anthropic format
+  const anthropicEvents = [];
+  let messageId = `msg_${Date.now()}`;
+  let contentIndex = 0;
+  let accumulatedText = '';
+
+  // Simulate message start
+  anthropicEvents.push({
+    event: 'message_start',
+    data: {
+      type: 'message_start',
+      message: {
+        id: messageId,
+        type: 'message',
+        role: 'assistant',
+        content: [],
+        model: 'gpt-4o-mini',
+        stop_reason: null,
+        stop_sequence: null,
+        usage: {
+          input_tokens: 0,
+          output_tokens: 0
+        }
+      }
+    }
+  });
+
+  // Process text content
+  for (const item of data) {
+    if (item.includes('response.output_text.delta')) {
+      const match = item.match(/"delta":"([^"]*)"/);
+      if (match) {
+        accumulatedText += match[1];
+      }
+    }
+  }
+
+  // Add content block
+  anthropicEvents.push({
+    event: 'content_block_start',
+    data: {
+      type: 'content_block_start',
+      index: contentIndex,
+      content_block: {
+        type: 'text',
+        text: ''
+      }
+    }
+  });
+
+  // Add the accumulated text
+  anthropicEvents.push({
+    event: 'content_block_delta',
+    data: {
+      type: 'content_block_delta',
+      index: contentIndex,
+      delta: {
+        type: 'text_delta',
+        text: accumulatedText
+      }
+    }
+  });
+
+  // Close content block
+  anthropicEvents.push({
+    event: 'content_block_stop',
+    data: {
+      type: 'content_block_stop',
+      index: contentIndex
+    }
+  });
+
+  // Message delta and stop
+  anthropicEvents.push({
+    event: 'message_delta',
+    data: {
+      type: 'message_delta',
+      delta: {
+        stop_reason: 'end_turn',
+        stop_sequence: null
+      },
+      usage: {
+        input_tokens: 10,
+        output_tokens: accumulatedText.length,
+        cache_read_input_tokens: 0
+      }
+    }
+  });
+
+  anthropicEvents.push({
+    event: 'message_stop',
+    data: {
+      type: 'message_stop'
+    }
+  });
+
+  return anthropicEvents;
+}
+
+// Usage examples
+async function runExamples() {
+  console.log('=== Simple Transform Example ===');
+  const simpleResult = simpleTransformResponse(exampleStreamData);
+  simpleResult.forEach(event => {
+    console.log(`${event.event}:`, JSON.stringify(event.data, null, 2));
+  });
+
+  console.log('\n=== Full Transform Example ===');
+  try {
+    await transformResponseIn(exampleStreamData);
+  } catch (error) {
+    console.error('Error:', error.message);
+  }
+}
+
+// Export the functions
+export { transformResponseIn, simpleTransformResponse, runExamples };
+
+// Run examples if this file is executed directly
+if (import.meta.url === `file://${process.argv[1]}`) {
+  runExamples();
+}

package/tests/test-lazy-load.js

@@ -0,0 +1,36 @@
+/**
+ * 测试懒加载MCP Server的启动性能
+ */
+import { startMCPServerProxy } from '../codex/mcpserver.js';
+import LogManager from '../logger-manager.js';
+
+const logger = LogManager.getSystemLogger();
+
+console.log('=== 测试MCP Server懒加载性能 ===');
+
+// 记录启动开始时间
+const startTime = Date.now();
+
+logger.info('开始启动MCP Server代理...');
+
+// 启动MCP Server代理（现在不会立即连接所有MCP服务）
+startMCPServerProxy();
+
+// 记录启动完成时间
+const endTime = Date.now();
+const startupTime = endTime - startTime;
+
+console.log(`\n=== 测试结果 ===`);
+console.log(`MCP Server代理启动时间: ${startupTime}ms`);
+console.log(`启动方式: 懒加载（不会立即连接所有MCP服务）`);
+console.log(`状态: 代理服务已启动，等待客户端请求时才会连接具体的MCP服务`);
+
+logger.info(`MCP Server代理启动完成，耗时: ${startupTime}ms`);
+
+// 保持进程运行一段时间以便观察
+setTimeout(() => {
+    console.log('\n=== 测试完成 ===');
+    console.log('MCP Server代理采用懒加载机制，只有在收到客户端请求时才会连接对应的MCP服务');
+    console.log('这样可以显著减少启动时间，特别是当配置了多个MCP服务时');
+    process.exit(0);
+}, 3000);

package/tests/test.js

@@ -0,0 +1,30 @@
+import {} from "../clogger.js"
+import Anthropic from "@anthropic-ai/sdk";
+
+
+const anthropic = new Anthropic({
+   apiKey: "sk-c1GF5uhjQpEcfqYZE3XvGf85XGpG7Rhj6E5829M3qoawzDzu",                         // 你的 key
+  // 如果你走 DeepSeek 的 Anthropic 兼容端点，也加上 baseURL：
+   baseURL: "https://api.moonshot.cn/anthropic",
+});
+
+const message = await anthropic.messages.create({
+  model: "kimi-k2-0905-preview",        // 用冒号
+  max_tokens: 1000,
+  system: "You are a helpful assistant.",
+  messages: [
+    {
+      role: "user",
+      content: [
+        { type: "text", text: "Hi, how are you?" }
+      ]
+    }
+  ]
+});
+
+console.log(message.content);    // 用 console.log 而不是 print
+
+
+
+
+

package/tests/test_mcp_proxy.js

@@ -0,0 +1,51 @@
+import { spawn } from 'child_process';
+import JsonRpcClient from '../codex/mcpclient.js';
+import LogManager from '../logger-manager.js';
+
+const logger = LogManager.getSystemLogger();
+
+async function testMCPProxy() {
+  logger.debug('Starting MCP proxy server test...');
+  
+  // Start the MCP proxy server
+  const proxyProcess = spawn('node', ['../codex/mcpserverproxy.js', '--mcpServerName=supabase'], {
+    stdio: ['pipe', 'pipe', 'pipe']
+  });
+  
+  proxyProcess.stderr.on('data', (data) => {
+    logger.error('Proxy stderr:', data.toString());
+  });
+  
+  proxyProcess.stdout.on('data', (data) => {
+    logger.debug('Proxy stdout:', data.toString());
+  });
+  
+  // Wait a bit for the server to start
+  await new Promise(resolve => setTimeout(resolve, 2000));
+  
+  try {
+    logger.debug('Creating JSON-RPC client...');
+    const client = new JsonRpcClient();
+    
+    logger.debug('Testing initialize...');
+    const initResult = await client.call('supabase_initialize');
+    logger.debug('Initialize result:', JSON.stringify(initResult, null, 2));
+    
+    logger.debug('Testing list tools...');
+    const toolsResult = await client.call('supabase_list');
+    logger.debug('Tools result:', JSON.stringify(toolsResult, null, 2));
+    
+    if (toolsResult && toolsResult.tools) {
+      logger.debug(`Found ${toolsResult.tools.length} tools via proxy`);
+    } else {
+      logger.debug('No tools found via proxy or unexpected format');
+    }
+    
+  } catch (error) {
+    console.error('Error testing MCP proxy:', error);
+  } finally {
+    proxyProcess.kill();
+  }
+}
+
+testMCPProxy();