@mseep/anything-analyzer 3.6.50

package/src/main/logger.ts

@@ -0,0 +1,42 @@
+import log from "electron-log/main";
+import { app } from "electron";
+import { join } from "path";
+
+/**
+ * Initialize electron-log for persistent file logging.
+ * Log files are stored in the app's userData/logs directory.
+ *
+ * Must be called after app.whenReady() since it uses app.getPath().
+ */
+export function initLogger(): void {
+  // Store logs in userData/logs/
+  const logDir = join(app.getPath("userData"), "logs");
+  log.transports.file.resolvePathFn = () => join(logDir, "main.log");
+
+  // Keep max 5MB per file, rotate up to 3 old files
+  log.transports.file.maxSize = 5 * 1024 * 1024;
+
+  // Log level: info and above go to file, all go to console in dev
+  log.transports.file.level = "info";
+  log.transports.console.level = process.env.NODE_ENV === "development" ? "debug" : "warn";
+
+  // Format: [timestamp] [level] message
+  log.transports.file.format = "[{y}-{m}-{d} {h}:{i}:{s}.{ms}] [{level}] {text}";
+
+  // Override console methods so existing console.log/warn/error
+  // statements throughout the codebase are automatically captured.
+  log.initialize();
+
+  log.info("=== Application started ===");
+  log.info(`Version: ${app.getVersion()}, Platform: ${process.platform} ${process.arch}`);
+  log.info(`Electron: ${process.versions.electron}, Node: ${process.versions.node}`);
+}
+
+/**
+ * Get the directory containing log files.
+ */
+export function getLogPath(): string {
+  return join(app.getPath("userData"), "logs", "main.log");
+}
+
+export default log;

package/src/main/mcp/mcp-config.ts

@@ -0,0 +1,66 @@
+import { readFileSync, writeFileSync, existsSync } from "fs";
+import { join } from "path";
+import { app } from "electron";
+import type { MCPServerConfig } from "@shared/types";
+
+function getConfigPath(): string {
+  return join(app.getPath("userData"), "mcp-servers.json");
+}
+
+/**
+ * 将缺少 transport 字段的旧配置迁移为 stdio 类型
+ */
+function migrateConfig(raw: Record<string, unknown>): MCPServerConfig {
+  if (!raw.transport) {
+    return {
+      id: raw.id as string,
+      name: raw.name as string,
+      enabled: raw.enabled as boolean,
+      transport: "stdio",
+      command: (raw.command as string) || "",
+      args: (raw.args as string[]) || [],
+      env: (raw.env as Record<string, string>) || {},
+    };
+  }
+  return raw as unknown as MCPServerConfig;
+}
+
+/**
+ * Load MCP server configs from disk. Returns empty array if file does not exist.
+ */
+export function loadMCPServers(): MCPServerConfig[] {
+  const path = getConfigPath();
+  if (!existsSync(path)) return [];
+  try {
+    const parsed = JSON.parse(readFileSync(path, "utf-8")) as Record<string, unknown>[];
+    return parsed.map(migrateConfig);
+  } catch {
+    return [];
+  }
+}
+
+function persist(servers: MCPServerConfig[]): void {
+  writeFileSync(getConfigPath(), JSON.stringify(servers, null, 2), "utf-8");
+}
+
+/**
+ * Save (create or update) a server config.
+ */
+export function saveMCPServer(server: MCPServerConfig): void {
+  const servers = loadMCPServers();
+  const idx = servers.findIndex((s) => s.id === server.id);
+  if (idx >= 0) {
+    servers[idx] = server;
+  } else {
+    servers.push(server);
+  }
+  persist(servers);
+}
+
+/**
+ * Delete a server config by ID.
+ */
+export function deleteMCPServer(id: string): void {
+  const servers = loadMCPServers();
+  persist(servers.filter((s) => s.id !== id));
+}

package/src/main/mcp/mcp-manager.ts

@@ -0,0 +1,155 @@
+import { Client } from "@modelcontextprotocol/sdk/client";
+// Must use explicit .js extension for CJS require resolution in Electron main process
+import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
+import { StreamableHTTPClientTransport } from "@modelcontextprotocol/sdk/client/streamableHttp.js";
+import type { Transport } from "@modelcontextprotocol/sdk/shared/transport.js";
+import type { MCPServerConfig } from "@shared/types";
+
+/**
+ * MCP 工具描述，包含来源信息
+ */
+export interface MCPToolInfo {
+  serverName: string;
+  name: string;
+  description: string;
+  inputSchema: Record<string, unknown>;
+}
+
+interface ConnectedServer {
+  config: MCPServerConfig;
+  client: Client;
+  transport: Transport;
+  tools: MCPToolInfo[];
+}
+
+/**
+ * 管理 MCP 服务器连接，提供统一的工具列表和调用接口。
+ */
+export class MCPClientManager {
+  private servers = new Map<string, ConnectedServer>();
+
+  /**
+   * 连接单个 MCP 服务器
+   */
+  async connect(config: MCPServerConfig): Promise<void> {
+    if (this.servers.has(config.id)) {
+      await this.disconnect(config.id);
+    }
+
+    let transport: Transport;
+
+    if (config.transport === "streamableHttp") {
+      const url = new URL(config.url);
+      transport = new StreamableHTTPClientTransport(url, {
+        requestInit: config.headers && Object.keys(config.headers).length > 0
+          ? { headers: config.headers }
+          : undefined,
+      });
+    } else {
+      transport = new StdioClientTransport({
+        command: config.command,
+        args: config.args,
+        env: { ...process.env, ...config.env } as Record<string, string>,
+      });
+    }
+
+    const client = new Client(
+      { name: "anything-analyzer", version: "1.0.0" },
+    );
+
+    await client.connect(transport);
+
+    // 获取工具列表
+    const { tools } = await client.listTools();
+    const toolInfos: MCPToolInfo[] = tools.map((t) => ({
+      serverName: config.name,
+      name: t.name,
+      description: t.description ?? "",
+      inputSchema: t.inputSchema as Record<string, unknown>,
+    }));
+
+    this.servers.set(config.id, { config, client, transport, tools: toolInfos });
+    console.log(`[MCP] Connected to ${config.name}, tools: ${toolInfos.map((t) => t.name).join(", ")}`);
+  }
+
+  /**
+   * 断开单个服务器连接
+   */
+  async disconnect(id: string): Promise<void> {
+    const server = this.servers.get(id);
+    if (!server) return;
+    try {
+      await server.client.close();
+    } catch {
+      // ignore close errors
+    }
+    this.servers.delete(id);
+  }
+
+  /**
+   * 断开所有连接
+   */
+  async disconnectAll(): Promise<void> {
+    const ids = [...this.servers.keys()];
+    await Promise.allSettled(ids.map((id) => this.disconnect(id)));
+  }
+
+  /**
+   * 连接所有启用的服务器
+   */
+  async connectAll(configs: MCPServerConfig[]): Promise<void> {
+    const enabled = configs.filter((c) => c.enabled);
+    await Promise.allSettled(
+      enabled.map((c) => this.connect(c).catch((err) => {
+        console.error(`[MCP] Failed to connect ${c.name}:`, err);
+      })),
+    );
+  }
+
+  /**
+   * 列出所有已连接服务器的工具
+   */
+  listAllTools(): MCPToolInfo[] {
+    const all: MCPToolInfo[] = [];
+    for (const server of this.servers.values()) {
+      all.push(...server.tools);
+    }
+    return all;
+  }
+
+  /**
+   * 调用工具（路由到正确的 MCP 客户端）
+   */
+  async callTool(toolName: string, args: Record<string, unknown>): Promise<string> {
+    for (const server of this.servers.values()) {
+      const tool = server.tools.find((t) => t.name === toolName);
+      if (tool) {
+        const result = await server.client.callTool({ name: toolName, arguments: args });
+        // 将结果内容拼接为文本
+        if (result.isError) {
+          const errorText = Array.isArray(result.content)
+            ? result.content.map((c: { type: string; text?: string }) => c.type === "text" ? c.text ?? "" : "").join("\n")
+            : String(result.content);
+          throw new Error(`Tool ${toolName} error: ${errorText}`);
+        }
+        const textParts: string[] = [];
+        if (Array.isArray(result.content)) {
+          for (const item of result.content as Array<{ type: string; text?: string }>) {
+            if (item.type === "text" && item.text) {
+              textParts.push(item.text);
+            }
+          }
+        }
+        return textParts.join("\n") || JSON.stringify(result.content);
+      }
+    }
+    throw new Error(`Tool not found: ${toolName}`);
+  }
+
+  /**
+   * 是否有已连接的服务器
+   */
+  hasConnections(): boolean {
+    return this.servers.size > 0;
+  }
+}