@dahawa/hawa-cli-analysis 1.0.4

package/codex/mcpserver.js

@@ -0,0 +1,374 @@
+/**
+ * 代理 MCP 服务是可以单独进行的，理论上一台机器只需要启动一个代理进程，便可以处理来自多个客户端的请求。
+ * 但是如果主进程关闭，代理进程也会随之关闭。
+ */
+import net from 'node:net';
+import fs from 'fs';
+import { pathToFileURL } from "url";
+import { Client } from "@modelcontextprotocol/sdk/client/index.js";
+import { StreamableHTTPClientTransport } from '@modelcontextprotocol/sdk/client/streamableHttp.js';
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import {loadMCPConfig,initMCPConfig} from "../config.js"
+import { SSEClientTransport } from '@modelcontextprotocol/sdk/client/sse.js';
+import { Client as OauthClient, StreamableHTTPClientTransport as  OauthStreamableHTTPClientTransport} from './mcp-client.js';
+import {getMcpOauthTokensPath , getPipePath } from '../untils.js';
+import LogManager from "../logger-manager.js";
+const logger = LogManager.getSystemLogger();
+
+const PIPE_PATH = await getPipePath();
+
+logger.debug("MCPServer PIPE_PATH:" + PIPE_PATH);
+
+        initMCPConfig();
+ let mcpConfig = loadMCPConfig();
+/**
+ * 启动 local mcp 服务
+ * {
+ *  command:""
+ *  args:[]，
+ *  evn：{}
+ * }
+ * @returns 
+ */
+async function createLocalClient(config){
+  //让客户端以“子进程”方式拉起/连接本地 stdio server
+  const transport = new StdioClientTransport({
+    command:config.command,
+    args:config.args,
+    env:config.env?config.env:{}
+  });
+
+  const client = new Client({
+    name: "demo-node-client",
+    version: "1.0.0",
+  });
+
+  await client.connect(transport);
+  logger.debug("Client connected");
+  return client;
+}
+/**
+ * url
+ * bearer_token 
+ * @returns 
+ */
+async function createRemoteClient(config){
+  // 先尝试 Streamable HTTP
+  try {
+    const client = new Client({ name: 'node-client', version: '1.0.0' });
+    const transport = new StreamableHTTPClientTransport(new URL(config.url), {
+      // 可选：传自定义 header（如 Authorization）
+      requestInit: config.bearer_token ? { headers: { Authorization: `Bearer ${config.bearer_token}` } } : undefined,
+      // 也可在这里传 Cookie / X-... 等企业网关要求的头
+    });
+    await client.connect(transport);
+    logger.debug('✅ Connected via Streamable HTTP');
+    //const tools = await client.listTools();
+    //console.log('Tools:', tools.tools.map(t => t.name));
+    return client;
+  } catch (err) {
+    logger.debug('Streamable HTTP failed, fallback to SSE...', err?.message);
+  }
+
+  // 回退到 SSE（老服务或未升级的实现）
+  const client = new Client({ name: 'node-client-sse', version: '1.0.0' });
+  const sse = new SSEClientTransport(new URL(config.url), {
+    requestInit: config.bearer_token ? { headers: { Authorization: `Bearer ${config.bearer_token}` } } : undefined,
+  });
+
+  
+  await client.connect(sse);
+  logger.debug('✅ Connected via SSE');
+  //const tools = await client.listTools();
+  //console.log('Tools:', tools.tools.map(t => t.name));
+  return client;
+}
+/**
+ * 创建需要登录的远程客户端
+ * @param {} config 
+ */
+async function createRemoteOauthClient(config){
+  //console.log("createRemoteOauthClient",config);
+  const issuer = config.issuer; //'https://radar.mcp.cloudflare.com';
+  const client = new OauthClient({ name: 'radar-demo', version: '1.0.0' });
+  const transport = new OauthStreamableHTTPClientTransport(config.url, {
+    oauth: {
+      issuer,
+      redirectUri: 'http://127.0.0.1:53175/callback',
+      tokenStorePath: getMcpOauthTokensPath(),
+      clientName: 'demo-radar-auto-reg',
+      debug: true
+    }
+      
+  });
+
+  await client.connect(transport);             // 需要登录时会自动拉起浏览器
+  //console.log('Radar tools:', await client.listTools());
+  return client;
+}
+/**
+ * 查询启用状态的的 MCP 配置
+ */
+function loadEnableMCPConfigs(){
+  let allMCPs = {
+      count: 0,
+      mcpServers: {}
+  };
+  for (const key in mcpConfig.mcpServers) {
+       let config = mcpConfig.mcpServers[key]; 
+       if(!config.disable){
+          allMCPs.mcpServers[key] = config;
+          allMCPs.count++;
+       }
+       
+  }
+  return allMCPs;
+}
+
+/**
+ * 过滤和改写 tools
+ * @param {string} mcpName - MCP 服务名称
+ * @param {Array} tools - 原始 tools 列表
+ * @returns {Array} - 过滤和改写后的 tools 列表
+ */
+function filterAndRewriteTools(mcpName, tools) {
+  const config = mcpConfig.mcpServers[mcpName];
+  if (!config || !config.tools) {
+    return tools;
+  }
+
+  let filteredTools = tools;
+
+  // 应用黑名单过滤
+  if (config.tools.blacklist && Array.isArray(config.tools.blacklist)) {
+    filteredTools = tools.filter(tool => 
+      !config.tools.blacklist.includes(tool.name)
+    );
+  }
+
+  // 应用描述改写
+  if (config.tools.descriptions && typeof config.tools.descriptions === 'object') {
+    filteredTools = filteredTools.map(tool => {
+      if (config.tools.descriptions[tool.name]) {
+        return {
+          ...tool,
+          description: config.tools.descriptions[tool.name]
+        };
+      }
+      return tool;
+    });
+  }
+
+  return filteredTools;
+}
+
+let allMCPClients = {};
+let allMCPConfigs = {};
+let enabledMCPs = loadEnableMCPConfigs().mcpServers;
+//console.log("Enabled MCPs:", enabledMCPs);
+
+// 只保存配置，不立即连接
+for (const key in enabledMCPs) {
+    allMCPConfigs[key] = enabledMCPs[key];
+    // 初始化客户端为null，表示未连接
+    allMCPClients[key] = null;
+}
+
+//创建本地连接
+//let client = await createLocalClient();
+
+/**
+ * 懒加载MCP客户端
+ * 如果客户端未连接，则根据配置创建连接
+ * @param {string} name - MCP服务名称
+ * @returns {Promise<object>} - 返回连接的客户端
+ */
+async function getOrCreateMCPClient(name) {
+  // 如果客户端已存在且已连接，直接返回
+  if (allMCPClients[name]) {
+    return allMCPClients[name];
+  }
+
+  // 获取配置
+  const config = allMCPConfigs[name];
+  if (!config) {
+    logger.error("MCP configuration not found for: " + name + " 检查配置文件是否缺失配置，或者 " + name + " 已经被禁用 " );
+    return null;
+  }
+
+  logger.debug(`懒加载创建MCP客户端: ${name}`);
+
+  try {
+    // 根据配置类型创建客户端
+    if(config.issuer&&config.url){
+      allMCPClients[name] = await createRemoteOauthClient(config);
+    }else if (config.url) {
+      allMCPClients[name] = await createRemoteClient(config);
+    }else{
+      allMCPClients[name] = await createLocalClient(config);
+    }
+
+    logger.debug(`MCP客户端创建成功: ${name}`);
+    return allMCPClients[name];
+  } catch (error) {
+    logger.error(`创建MCP客户端失败 ${name}:`, error);
+    throw error;
+  }
+}
+
+function getMCPClient(name) {
+  return allMCPClients[name];
+}
+function getMCPNameMethod(method){
+    let  res = {
+      //MCP 服务名称
+      name:"",
+      //Tool 方法名称
+      method:"",
+      mcpClient:""
+    }
+    res.name   = method.split("_")[0];
+    res.method = method.substring(res.name.length + 1);
+    //console.log(res.name);
+    res.mcpClient = getMCPClient(res.name);
+    //console.log(">>"+res.mcpClient);
+    return res;
+}
+
+
+// 用户实现：统一请求处理器（返回值作为 result，抛错则作为 error）
+export async function handle(methodfull, params, id, socket ) {
+      logger.debug(" mcpserver Handling request:" + JSON.stringify({ methodfull, params, id }));
+      let {name, mcpClient,method} = getMCPNameMethod(methodfull);
+
+      // 使用懒加载获取客户端
+      if(!mcpClient){
+        logger.debug(`MCP Client not found for: ${name}, attempting lazy load...`);
+        try {
+          mcpClient = await getOrCreateMCPClient(name);
+          if (!mcpClient) {
+            logger.error("MCP Client creation failed for: " + name);
+            throw new Error(`McpServer not found: ${name}` + " 检查 mcpserver 是否已经配置，或者被禁用  " );
+          }
+        } catch (error) {
+          logger.error(`Failed to create MCP client for ${name}:`, error);
+          throw new Error(`Failed to connect to MCP server: ${name} - ${error.message}`);
+        }
+      }
+
+      if (method === 'initialize'){
+        //新版本已经在 await client.connect(transport); 完成协商，不需要处理
+        //这里是可以通过
+        if(mcpClient._initializeInfo){
+          return mcpClient._initializeInfo;
+        }else if (mcpClient.initialize){
+          return await mcpClient.initialize({
+                  clientInfo: {
+                    name: 'my-client',
+                    version: '0.1.0',
+                  },
+                  capabilities: {
+                    tools: true,
+                    resources: true,
+                    logging: false,
+                  },
+                });
+        }else{
+          let initialize = {
+              //不知道怎么获取
+              "protocolVersion":mcpClient.transport.protocolVersion?mcpClient.transport.protocolVersion:"2025-03-26",
+              "serverInfo": mcpClient.getServerVersion(),
+              "capabilities": mcpClient.getServerCapabilities(),
+              "instructions": mcpClient["_instructions"]? mcpClient["_instructions"]:""
+          };
+          //console.log("Initialize1:", JSON.stringify(initialize, null, 2));
+          return initialize;
+        }
+
+      }
+
+      if (method === 'list') {
+        let tools = await mcpClient.listTools();
+        // 应用黑名单过滤和描述改写
+        if (tools && tools.tools) {
+          tools.tools = filterAndRewriteTools(name, tools.tools);
+        }
+        logger.debug("Tools:" + JSON.stringify(tools, null, 2));
+        return tools;
+      };
+      if (method === 'call') {
+        let result = await mcpClient.callTool({ name: params?.name, arguments: params?.arguments });
+        //console.log("Call result:", JSON.stringify(result, null, 2));
+        return result;
+      }
+      throw new Error(`McpServer Method not found: ${method}`);
+
+}
+
+const respond = (sock, id, result, error) => {
+  const msg = { jsonrpc: '2.0', id: id ?? null };
+  error ? (msg.error = { code: -32000, message: String(error) }) : (msg.result = result);
+  sock.write(JSON.stringify(msg) + '\n');
+};
+
+export function startMCPServerProxy(){
+   let start = false
+   for(const key in mcpConfig.mcpServers){
+        if(key){
+          start =true;
+          break;
+        }
+    }
+
+  if(!start){
+    logger.debug("当前没有配置 MCP Server ，无需启动代理服务。");
+    return;
+  }  
+
+   const rpcserver = net.createServer((socket) => {
+    let buf = '';
+    socket.on('data', (chunk) => {
+      buf += chunk;
+      for (let i = buf.indexOf('\n'); i >= 0; i = buf.indexOf('\n')) {
+        const line = buf.slice(0, i).trim(); buf = buf.slice(i + 1);
+        //console.log("Received line:", line);
+        if (!line) continue;
+
+        let req;
+        try { req = JSON.parse(line); }
+        catch { return respond(socket, null, null, 'Parse error: invalid JSON'); }
+
+        const { jsonrpc, id, method, params } = req ?? {};
+        if (jsonrpc !== '2.0' || typeof method !== 'string' || !('id' in (req ?? {}))) {
+          return respond(socket, ('id' in (req ?? {})) ? id : null, null, 'Invalid JSON-RPC request');
+        }
+
+        Promise.resolve(handle(req.method, req.params, req.id, socket))
+          .then((res) => respond(socket, id, res))
+          .catch((err) => respond(socket, id, null, err?.message || err));
+      }
+    });
+    socket.on('error', () => {});
+  });
+  
+  //如果已经存在删除
+  if (fs.existsSync(PIPE_PATH)){
+      try {
+        fs.unlinkSync(PIPE_PATH);
+      } catch (error) {
+        logger.debug('无法删除已存在的管道文件，可能正在被使用:', error.message);
+      }
+  }
+
+  rpcserver.listen(PIPE_PATH, () => {
+    logger.debug('JSON-RPC server listening on', PIPE_PATH);
+  });
+  
+}
+
+function main() {
+  logger.debug('Starting MCP Server Proxy...');
+  startMCPServerProxy();
+}
+
+//main();

package/codex/mcpserverproxy.js

@@ -0,0 +1,144 @@
+import JsonRpcClient from "./mcpclient.js"
+import { pathToFileURL } from "url";
+import readline from 'node:readline';
+import {getOptions} from "../untils.js"
+import LogManager from "../logger-manager.js";
+const logger = LogManager.getSystemLogger();
+
+// ---- 2) JSON-RPC 帮助函数 ----
+function send(resultOrError, id) {
+  const msg = { jsonrpc: '2.0', ...(resultOrError.error ? { error: resultOrError.error } : { result: resultOrError.result }), id };
+  process.stdout.write(JSON.stringify(msg) + '\n');
+}
+
+function error(code, message, data) {
+  return { error: { code, message, ...(data !== undefined ? { data } : {}) } };
+}
+
+function ok(result) {
+  return { result };
+}
+let  mcpServerName = getOptions().mcpServerName;
+if(!mcpServerName){
+   logger.error("MCP server name is required --mcpServerName=supabase");
+   process.exit(1);
+}
+
+logger.debug("执行代理 MCPServer " + mcpServerName);
+
+// 这里执行异步连接 mcpServer，不需要启动的时候全部连接
+let  mcpclient  = new JsonRpcClient();
+
+logger.debug("执行代理 MCPServer , 创建客户端成功 " );
+
+
+// ---- 3) 处理 JSON-RPC 请求 ----
+async function handleRequest({ id, method, params }) {
+  logger.debug(` handleRequest  ${mcpServerName} ` + JSON.stringify({id,method,params}));
+  try {
+    // a) 初始化握手（极简实现）
+    if (method === 'initialize') {
+      /**   
+      return send(
+        ok({
+          protocolVersion: '2025-03-26', // 示例：协议版本字符串
+          capabilities: { tools: {} },   // 表示支持工具子协议
+          serverInfo: { name: 'Supabase', version: '0.0.1' },
+        }),
+        id,
+      );
+      */
+        let res = await mcpclient.call(`${mcpServerName}_initialize`);
+        logger.debug(" mcpclient result:  " + JSON.stringify(res));
+        return send(ok(res), id);
+    }
+
+    // b) 列出工具
+    if (method === 'tools/list') {
+        let tools = await mcpclient.call(`${mcpServerName}_list`);
+        return send(ok(tools), id);
+    }
+
+    // c) 调用工具
+    if (method === 'tools/call') {
+        let result = await mcpclient.call(`${mcpServerName}_call`, params);
+        return send(ok(result ?? { content: [] }), id);      
+    }
+
+    // d) 可选心跳
+    if (method === 'ping') return send(ok({}), id);
+
+    // e) 未实现的方法
+    return send(error(-32601, `Method not found: ${method}`), id);
+  } catch (e) {
+    logger.error(` handleRequest  ${mcpServerName}  error ` + e?.message + "  " + e + "\nStack trace: " + e.stack);
+    return send(error(-32603, 'Internal error ' + e?.message , { message: String(e?.message || e) }), id);
+  }
+}
+
+// ---- 4) 读 STDIN（每行一个 JSON-RPC 消息） ----
+const rl = readline.createInterface({ input: process.stdin, crlfDelay: Infinity });
+
+rl.on('line', async (line) => {
+  if (!line.trim()) return;
+  let msg;
+  try {
+    msg = JSON.parse(line);
+  } catch {
+    // 非法 JSON：按 JSON-RPC 返回解析错误
+    return send(error(-32700, 'Parse error'), null);
+  }
+
+  // 只处理 Request；Notification 没有 id
+  if (msg?.jsonrpc !== '2.0' || typeof msg?.method !== 'string') {
+    return send(error(-32600, 'Invalid Request'), msg?.id ?? null);
+  }
+  // 异步处理
+  handleRequest(msg);
+});
+
+// 可选：把错误打印到 stderr（不影响 JSON-RPC 数据流）
+process.on('uncaughtException', (e) => console.error('uncaught:', e));
+process.on('unhandledRejection', (e) => console.error('unhandled:', e));
+
+//console.log(`mcpclient.call('${mcpServerName}_list')`);
+//let tools = await mcpclient.call(`${mcpServerName}_list`);
+//console.log(JSON.stringify(tools, null, 2));
+async function main(){
+   logger.debug(`mcpclient.call('${mcpServerName}_initialize')`);
+   try {
+       let initialize = await mcpclient.call(`${mcpServerName}_initialize`);
+       logger.debug(JSON.stringify(initialize, null, 2));
+   } catch (error) {
+       logger.error("Error initializing MCP client:", error);
+   }
+}
+
+/**
+ * 判断当前模块是否是主运行模块：
+ * ✅ node xxx.js 直接执行 → true
+ * 🚫 import 时 → false
+ * 🚫 子进程 (spawn/fork) 启动时 → false
+ */
+export function isMainModule() {
+  // 当前模块文件 URL
+  const currentFile = pathToFileURL(process.argv[1]).href;
+
+  // 是否为直接运行
+  const isDirectRun = import.meta.url === currentFile;
+
+  // 是否为子进程
+  const isChildProcess =
+    process.send !== undefined ||
+    process.env.__IS_SUBPROCESS__ === "1" ||
+    (process.ppid !== 1 && process.ppid !== process.pid);
+   logger.debug("isChildProcess:",  isDirectRun && !isChildProcess);
+  return isDirectRun && !isChildProcess;
+}
+
+//if(isMainModule()){
+// main();
+//}
+
+logger.debug("Environment Variables: " + JSON.stringify(process.env, null, 2));
+logger.debug("Process Arguments: " + JSON.stringify(process.argv, null, 2));

package/codex/test.js

@@ -0,0 +1,30 @@
+import { Client, StreamableHTTPClientTransport } from './mcp-client.js';
+import LogManager from '../logger-manager.js';
+
+const logger = LogManager.getSystemLogger();
+
+const issuer = 'https://radar.mcp.cloudflare.com';
+const client = new Client({ name: 'radar-demo', version: '1.0.0' });
+const transport = new StreamableHTTPClientTransport(`${issuer}/mcp`, {
+
+  oauth: {
+    issuer,
+    // 显式覆盖端点（根据你调试日志里看到的为准）
+    //authorizationUrl: `${issuer}/oauth/authorize`,
+    //tokenUrl:        `${issuer}/oauth/token`,
+    //registrationUrl: `${issuer}/oauth/register`,
+
+    // 先尝试动态注册；如报“no registration_endpoint”，请改为手动 clientId
+    // clientId: '从门户或运维处获得',
+    scopes: ['openid','profile','email','offline_access'],
+    redirectUri: 'http://127.0.0.1:53175/callback',
+    tokenStorePath: '.mcp_oauth_tokens.json',
+    clientName: 'demo-radar-auto-reg',
+    debug: true
+  }
+    
+});
+
+
+await client.connect(transport);             // 需要登录时会自动拉起浏览器
+logger.debug('Radar tools:', await client.listTools());

package/config.js

@@ -0,0 +1,105 @@
+import os   from 'os';
+import path from 'path';
+import fs from 'fs';
+
+let defaultConfig = {
+    "kimi-k2":{
+        enable:false,
+         env:{
+            BASE_URL:"https://api.moonshot.cn/anthropic",
+            AUTH_TOKEN:"sk-{ 使用自己的 token }",
+            MODEL:"kimi-k2-0905-preview",
+            SMALL_FAST_MODEL:"kimi-k2-0905-preview"
+        }
+    },
+    "deepseek":{
+        enable:false,
+        env:{
+             BASE_URL:"https://api.deepseek.com/anthropic",
+             AUTH_TOKEN:"sk-{ 使用自己的 token }",
+             API_TIMEOUT_MS:"600000",
+             MODEL:"deepseek-chat",
+             SMALL_FAST_MODEL:"deepseek-chat",
+             CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC:"1"
+        }
+    },
+    /**
+     * "anthropic/claude-sonnet-4",
+        "anthropic/claude-3.5-sonnet",
+        "anthropic/claude-3.7-sonnet:thinking"
+     */
+    "openrouter":{
+         enable:false,
+          env:{
+            "BASE_URL": "http://127.0.0.1:3000",
+            "AUTH_TOKEN": "sk-or-v1-{ 使用自己的 token }",
+            "MODEL": "anthropic/claude-sonnet-4",
+            "SMALL_FAST_MODEL": "anthropic/claude-sonnet-4"
+        }
+    }
+}
+
+function getConfigDir(){
+  let home = os.homedir();
+  return path.join(home, ".hawa-cli-analysis", "config.json");
+}
+
+/**
+ * init config dir
+ */
+export function initConfig(){
+  //如果路径不存在，创建
+  let dir =  getConfigDir();   
+  if (!fs.existsSync(dir)){
+      //创建初始化文件
+      fs.mkdirSync(path.dirname(dir), { recursive: true });
+      fs.writeFileSync(dir, JSON.stringify(defaultConfig,null, 2));
+  } 
+}
+
+export  function loadConfig(){
+   const data = fs.readFileSync(getConfigDir(), 'utf-8');
+   return JSON.parse(data);
+}
+
+
+
+let defaultMCPConfig = {
+  "mcpServers": {
+    "supabase": {
+      "url": "https://mcp.supabase.com/mcp",
+      "bearer_token":"sbp_xxxxx",
+      "tools": {
+        "blacklist": ["tool_name_to_exclude"],
+        "descriptions": {
+          "tool_name": "Custom description for this tool"
+        }
+      }
+    }
+  }
+
+}
+
+
+function getMCPConfigDir(){
+  let home = os.homedir();
+  return path.join(home, ".hawa-cli-analysis", "mcp.json");
+}
+
+/**
+ * init config dir
+ */
+export function initMCPConfig(){
+  //如果路径不存在，创建
+  let dir =  getMCPConfigDir();   
+  if (!fs.existsSync(dir)){
+      //创建初始化文件
+      fs.mkdirSync(path.dirname(dir), { recursive: true });
+      fs.writeFileSync(dir, JSON.stringify(defaultMCPConfig,null, 2));
+  } 
+}
+
+export  function loadMCPConfig(){
+   const data = fs.readFileSync(getMCPConfigDir(), 'utf-8');
+   return JSON.parse(data);
+}