@ww_nero/mini-cli 1.0.56

package/src/tools/mcp.js

@@ -0,0 +1,478 @@
+const fs = require('fs');
+const path = require('path');
+const crypto = require('crypto');
+const chalk = require('chalk');
+
+const { Client } = require('@modelcontextprotocol/sdk/client/index.js');
+const { StdioClientTransport } = require('@modelcontextprotocol/sdk/client/stdio.js');
+
+const { version: pkgVersion = '0.0.0' } = require('../../package.json');
+const { ensureConfigFiles, getConfigPath } = require('../config');
+const MAX_TOOL_NAME_LENGTH = 64;
+const MCP_TYPE_HTTP = 'http';
+const MCP_TYPE_STDIO = 'stdio';
+
+const isPlainObject = (value) => value && typeof value === 'object' && !Array.isArray(value);
+
+const getFetchImpl = () => {
+  if (typeof fetch === 'function') return fetch;
+  try {
+    return require('node-fetch');
+  } catch (_) {
+    return null;
+  }
+};
+
+const normalizeHeadersInput = (headers, HeadersCtor) => {
+  if (!headers) return {};
+  if (HeadersCtor && headers instanceof HeadersCtor) {
+    return Object.fromEntries(headers.entries());
+  }
+  if (Array.isArray(headers)) {
+    return Object.fromEntries(headers);
+  }
+  if (isPlainObject(headers)) {
+    return { ...headers };
+  }
+  return {};
+};
+
+const mergeHeaders = (baseHeaders = {}, extraHeaders = {}, HeadersCtor) => ({
+  ...normalizeHeadersInput(baseHeaders, HeadersCtor),
+  ...normalizeHeadersInput(extraHeaders, HeadersCtor)
+});
+
+const normalizeHeaderValues = (headers) => {
+  if (!isPlainObject(headers)) return {};
+  const result = {};
+  Object.entries(headers).forEach(([key, value]) => {
+    if (typeof key !== 'string' || !key.trim()) return;
+    result[key.trim()] = value == null ? '' : String(value);
+  });
+  return result;
+};
+
+const createHttpFetch = (headers = {}) => {
+  const fetchImpl = getFetchImpl();
+  if (!fetchImpl) return null;
+  const HeadersCtor = typeof Headers !== 'undefined' ? Headers : fetchImpl.Headers;
+  const defaultHeaders = normalizeHeadersInput(headers, HeadersCtor);
+
+  return async (url, options = {}) => {
+    const mergedHeaders = mergeHeaders(defaultHeaders, options.headers, HeadersCtor);
+    return fetchImpl(url, { ...options, headers: mergedHeaders });
+  };
+};
+
+const loadHttpTransports = () => {
+  try {
+    const { StreamableHTTPClientTransport } = require('@modelcontextprotocol/sdk/client/streamableHttp.js');
+    const { SSEClientTransport } = require('@modelcontextprotocol/sdk/client/sse.js');
+    return { StreamableHTTPClientTransport, SSEClientTransport };
+  } catch (error) {
+    console.log(chalk.yellow(`加载 HTTP MCP 传输失败：${error.message}`));
+    return {};
+  }
+};
+
+const buildHttpTransportOptions = (server) => {
+  const headers = normalizeHeaderValues(server && server.headers);
+  const options = {};
+
+  const fetchWithHeaders = createHttpFetch(headers);
+  if (fetchWithHeaders) {
+    options.fetch = fetchWithHeaders;
+  }
+
+  if (headers && Object.keys(headers).length > 0) {
+    options.headers = headers;
+  }
+
+  return options;
+};
+
+const getMcpConfigPath = () => getConfigPath('mcp');
+
+const readConfigFile = (configPath) => {
+  try {
+    if (!fs.existsSync(configPath)) {
+      return null;
+    }
+    const raw = fs.readFileSync(configPath, 'utf8');
+    if (!raw.trim()) {
+      return null;
+    }
+    return JSON.parse(raw);
+  } catch (error) {
+    console.log(chalk.yellow(`读取 ${configPath} 失败：${error.message}`));
+    return null;
+  }
+};
+
+const normalizeServerEntry = (entryName, rawEntry = {}) => {
+  if (!isPlainObject(rawEntry)) {
+    return null;
+  }
+
+  const typeRaw = typeof rawEntry.type === 'string' ? rawEntry.type.trim().toLowerCase() : MCP_TYPE_STDIO;
+  const type = typeRaw === MCP_TYPE_HTTP ? MCP_TYPE_HTTP : MCP_TYPE_STDIO;
+
+  const name = typeof rawEntry.name === 'string' && rawEntry.name.trim() ? rawEntry.name.trim() : entryName;
+  const tools = Array.isArray(rawEntry.tools) ? rawEntry.tools.map(String).filter(Boolean) : null;
+
+  if (type === MCP_TYPE_HTTP) {
+    const urlRaw = typeof rawEntry.url === 'string' ? rawEntry.url.trim() : '';
+    if (!urlRaw) {
+      return null;
+    }
+
+    let parsedUrl;
+    try {
+      parsedUrl = new URL(urlRaw);
+    } catch (_) {
+      return null;
+    }
+
+    const headers = normalizeHeaderValues(rawEntry.headers);
+
+    return {
+      type: MCP_TYPE_HTTP,
+      name,
+      url: parsedUrl.toString(),
+      headers,
+      tools
+    };
+  }
+
+  const command = typeof rawEntry.command === 'string' ? rawEntry.command.trim() : '';
+  if (!command) {
+    return null;
+  }
+
+  const args = Array.isArray(rawEntry.args) ? rawEntry.args.map(String) : [];
+  const env = rawEntry.env && typeof rawEntry.env === 'object' ? rawEntry.env : {};
+  const cwd = typeof rawEntry.cwd === 'string' && rawEntry.cwd.trim() ? rawEntry.cwd.trim() : null;
+
+  return {
+    type: MCP_TYPE_STDIO,
+    name,
+    command,
+    args,
+    env,
+    cwd,
+    tools
+  };
+};
+
+const loadMcpServers = (allowedNames = null) => {
+  ensureConfigFiles();
+  const configPath = getMcpConfigPath();
+  const parsed = readConfigFile(configPath);
+  const servers = [];
+
+  if (Array.isArray(allowedNames) && allowedNames.length === 0) {
+    return { configPath, servers };
+  }
+
+  if (!parsed || typeof parsed !== 'object') {
+    return { configPath, servers };
+  }
+
+  const entries = parsed.mcpServers && typeof parsed.mcpServers === 'object'
+    ? parsed.mcpServers
+    : {};
+
+  Object.entries(entries).forEach(([key, value]) => {
+    const normalized = normalizeServerEntry(key, value);
+    if (!normalized) {
+      return;
+    }
+    if (Array.isArray(allowedNames)) {
+      if (allowedNames.length === 0) {
+        return;
+      }
+      if (!allowedNames.includes(normalized.name)) {
+        return;
+      }
+    }
+    servers.push(normalized);
+  });
+
+  return { configPath, servers };
+};
+
+const sanitizeName = (value, fallback) => {
+  const safe = String(value || '').trim().replace(/[^a-zA-Z0-9_-]/g, '_');
+  return safe || fallback;
+};
+
+const buildToolCallName = (serverName, toolName) => {
+  // 构建带服务器前缀的工具名称，格式为 serverName_toolName
+  const prefix = sanitizeName(serverName, 'mcp');
+  const suffix = sanitizeName(toolName, 'tool');
+  const fullName = `${prefix}_${suffix}`;
+
+  if (fullName.length <= MAX_TOOL_NAME_LENGTH) {
+    return fullName;
+  }
+
+  // 如果名称过长，进行截断并添加哈希值以保证唯一性
+  const hash = crypto.createHash('md5').update(`${serverName}:${toolName}`).digest('hex').slice(0, 6);
+  const maxPrefixLength = Math.floor((MAX_TOOL_NAME_LENGTH - hash.length - 2) / 2);
+  const trimmedPrefix = prefix.slice(0, maxPrefixLength);
+  const trimmedSuffix = suffix.slice(0, MAX_TOOL_NAME_LENGTH - trimmedPrefix.length - hash.length - 2);
+  return `${trimmedPrefix}_${trimmedSuffix}_${hash}`;
+};
+
+const connectHttpClient = async (client, server) => {
+  const { StreamableHTTPClientTransport, SSEClientTransport } = loadHttpTransports();
+
+  if (!StreamableHTTPClientTransport && !SSEClientTransport) {
+    throw new Error('当前 SDK 版本不支持 HTTP 类型的 MCP 传输');
+  }
+
+  if (!server || !server.url) {
+    throw new Error('HTTP MCP 配置缺少 url');
+  }
+
+  let targetUrl;
+  try {
+    targetUrl = new URL(server.url);
+  } catch (_) {
+    throw new Error('HTTP MCP 配置的 url 无效');
+  }
+
+  const options = buildHttpTransportOptions(server);
+  const attempts = [];
+
+  if (StreamableHTTPClientTransport) {
+    attempts.push(() => new StreamableHTTPClientTransport(targetUrl, options));
+  }
+  if (SSEClientTransport) {
+    attempts.push(() => new SSEClientTransport(targetUrl, options));
+  }
+
+  let lastError = null;
+
+  for (const factory of attempts) {
+    const transport = factory();
+    try {
+      await client.connect(transport);
+      return transport;
+    } catch (error) {
+      lastError = error;
+      try {
+        await transport.close?.();
+      } catch (_) {
+        // ignore
+      }
+    }
+  }
+
+  throw lastError || new Error('HTTP MCP 连接失败');
+};
+
+const renderContentChunk = (chunk) => {
+  if (!chunk) return '';
+  if (typeof chunk === 'string') return chunk;
+  if (chunk.type === 'text' && typeof chunk.text === 'string') {
+    return chunk.text;
+  }
+  if (chunk.type === 'image' && chunk.data) {
+    return '[image content 已省略]';
+  }
+  if (chunk.type === 'resource' && chunk.uri) {
+    return `[resource] ${chunk.uri}`;
+  }
+  return (() => {
+    try {
+      return JSON.stringify(chunk, null, 2);
+    } catch (_) {
+      return String(chunk);
+    }
+  })();
+};
+
+const formatMcpContent = (content) => {
+  if (!content) return '';
+  if (Array.isArray(content)) {
+    return content
+      .map(renderContentChunk)
+      .filter(Boolean)
+      .join('\n---\n');
+  }
+  return renderContentChunk(content);
+};
+
+class McpManager {
+  constructor(workspaceRoot, allowedMcpNames = null) {
+    this.workspaceRoot = workspaceRoot;
+    this.allowedMcpNames = Array.isArray(allowedMcpNames) ? allowedMcpNames : null;
+    this.clients = [];
+  }
+
+  async initialize() {
+    const { configPath, servers } = loadMcpServers(this.allowedMcpNames);
+    this.configPath = configPath;
+
+    if (!servers || servers.length === 0) {
+      return;
+    }
+
+    for (const server of servers) {
+      await this.registerServer(server);
+    }
+  }
+
+  async registerServer(server) {
+    const client = new Client(
+      {
+        name: 'mini-cli',
+        version: pkgVersion
+      },
+      {
+        capabilities: {}
+      }
+    );
+
+    let transport = null;
+
+    try {
+      if (server.type === MCP_TYPE_HTTP) {
+        transport = await connectHttpClient(client, server);
+      } else {
+        const transportOptions = {
+          command: server.command,
+          args: server.args || [],
+          env: { ...process.env, ...server.env },
+          ...(server.cwd ? { cwd: server.cwd } : {}),
+          stderr: 'pipe'
+        };
+        transport = new StdioClientTransport(transportOptions);
+        await client.connect(transport);
+      }
+    } catch (error) {
+      console.log(chalk.yellow(`MCP 服务器 ${server.name} 连接失败：${error.message}`));
+      try {
+        await transport?.close?.();
+      } catch (_) {
+        // ignore close error
+      }
+      return;
+    }
+
+    const toolsResult = await (async () => {
+      try {
+        return await client.listTools();
+      } catch (error) {
+        console.log(chalk.yellow(`获取 MCP 工具失败 (${server.name})：${error.message}`));
+        return null;
+      }
+    })();
+
+    const tools = (toolsResult && Array.isArray(toolsResult.tools)) ? toolsResult.tools : [];
+
+    // 根据 server.tools 配置过滤工具
+    const filteredTools = server.tools && server.tools.length > 0
+      ? tools.filter(tool => server.tools.includes(tool.name))
+      : tools;
+
+    const registeredTools = filteredTools.map((tool) => {
+      const callName = buildToolCallName(server.name, tool.name);
+      const descriptionParts = [];
+      if (tool.description) {
+        descriptionParts.push(tool.description);
+      }
+      descriptionParts.push(`来源 MCP 服务器：${server.name}`);
+      const parameters = tool.inputSchema && typeof tool.inputSchema === 'object'
+        ? tool.inputSchema
+        : { type: 'object', properties: {} };
+      return {
+        name: callName,
+        isMcpTool: true, // 标记为 MCP 工具
+        schema: {
+          type: 'function',
+          function: {
+            name: callName,
+            description: descriptionParts.join('；'),
+            parameters
+          }
+        },
+        handler: async (args = {}) => {
+          try {
+            const result = await client.callTool(
+              {
+                name: tool.name,
+                arguments: args
+              },
+              undefined,
+              {
+                timeout: 600000 // 10 分钟超时
+              }
+            );
+            const isError = Boolean(result && result.isError);
+            const output = formatMcpContent(result && result.content);
+            if (isError) {
+              return output ? `MCP 工具返回错误：${output}` : 'MCP 工具返回错误';
+            }
+            return output || 'MCP 工具无输出';
+          } catch (error) {
+            return `调用 MCP 工具失败：${error.message}`;
+          }
+        }
+      };
+    });
+
+    this.clients.push({
+      server,
+      client,
+      transport,
+      tools: registeredTools
+    });
+  }
+
+  getTools() {
+    return this.clients.flatMap((entry) => entry.tools || []);
+  }
+
+  getConfigPath() {
+    return this.configPath;
+  }
+
+  getEnabledServerNames() {
+    return this.clients.map((entry) => entry.server.name);
+  }
+
+  async dispose() {
+    const closing = this.clients.map(async ({ client, transport }) => {
+      try {
+        await client.close?.();
+      } catch (_) {
+        // ignore
+      }
+      try {
+        await transport.close?.();
+      } catch (_) {
+        // ignore
+      }
+    });
+    await Promise.allSettled(closing);
+  }
+}
+
+const createMcpManager = async (workspaceRoot, allowedMcpNames = null) => {
+  if (Array.isArray(allowedMcpNames) && allowedMcpNames.length === 0) {
+    return null;
+  }
+  const manager = new McpManager(workspaceRoot, allowedMcpNames);
+  await manager.initialize();
+  const tools = manager.getTools();
+  if (!tools || tools.length === 0) {
+    return null;
+  }
+  return manager;
+};
+
+module.exports = {
+  createMcpManager
+};

package/src/tools/python/html_to_png.py

@@ -0,0 +1,100 @@
+"""Convert a single HTML file to PNG via Playwright screenshot."""
+from __future__ import annotations
+
+import argparse
+import sys
+from pathlib import Path
+
+from playwright.sync_api import sync_playwright
+
+
+MIN_WIDTH = 320
+MIN_HEIGHT = 240
+DEVICE_SCALE_FACTOR = 4
+
+
+def _find_target_element(page):
+    body = page.query_selector('body')
+    if body is None:
+        raise ValueError('未找到 body 元素')
+
+    top_level_elements = body.query_selector_all(':scope > *')
+    if not top_level_elements:
+        raise ValueError('body 中未找到可截图元素')
+
+    # 单个最外层节点时直接使用该节点，否则使用整个 body
+    return top_level_elements[0] if len(top_level_elements) == 1 else body
+
+
+def _measure_element(element):
+    size = element.evaluate(
+        """
+        (el) => {
+            const rect = el.getBoundingClientRect();
+            const width = Math.max(rect.width || 0, el.scrollWidth || 0, el.offsetWidth || 0);
+            const height = Math.max(rect.height || 0, el.scrollHeight || 0, el.offsetHeight || 0);
+            return { width, height };
+        }
+        """
+    )
+    width = max(1, int(size.get('width') or 0))
+    height = max(1, int(size.get('height') or 0))
+    return width, height
+
+
+def convert_html_to_png(input_file: str | Path, output_file: str | Path, wait_ms: int = 1500) -> Path:
+    """Convert a single HTML file to PNG image."""
+    html_path = Path(input_file).expanduser().resolve()
+    if not html_path.exists():
+        raise FileNotFoundError(f'HTML 文件不存在: {html_path}')
+
+    output_path = Path(output_file).expanduser().resolve()
+    output_path.parent.mkdir(parents=True, exist_ok=True)
+
+    with sync_playwright() as playwright:
+        browser = playwright.chromium.launch(headless=True)
+        context = browser.new_context(
+            viewport={'width': MIN_WIDTH, 'height': MIN_HEIGHT},
+            device_scale_factor=DEVICE_SCALE_FACTOR
+        )
+        page = context.new_page()
+        try:
+            file_url = html_path.as_uri()
+            page.goto(file_url)
+            page.wait_for_timeout(wait_ms)
+
+            target = _find_target_element(page)
+            element_width, element_height = _measure_element(target)
+            viewport_width = max(MIN_WIDTH, element_width)
+            viewport_height = max(MIN_HEIGHT, element_height)
+
+            page.set_viewport_size({'width': viewport_width, 'height': viewport_height})
+            page.wait_for_timeout(200)
+            target.screenshot(path=str(output_path))
+        finally:
+            context.close()
+            browser.close()
+
+    return output_path
+
+
+def _parse_args() -> argparse.Namespace:
+    parser = argparse.ArgumentParser(description='将 HTML 文件转换为 PNG 图片。')
+    parser.add_argument('--input', required=True, help='HTML 文件路径')
+    parser.add_argument('--output', required=True, help='输出 PNG 文件路径')
+    parser.add_argument('--wait', type=int, default=1500, help='页面加载等待时间，单位毫秒，默认 1500')
+    return parser.parse_args()
+
+
+def main() -> None:
+    args = _parse_args()
+    try:
+        result = convert_html_to_png(args.input, args.output, wait_ms=args.wait)
+        print(f'已生成 PNG: {result}')
+    except Exception as error:
+        print(f'转换失败: {error}', file=sys.stderr)
+        sys.exit(1)
+
+
+if __name__ == '__main__':
+    main()