refactor: 将 mcp-server 解耦为独立社区包

Co-authored-by: aider (vertex_ai/gemini-2.5-pro) <aider@aider.chat>

Author: Dango233

packages/cli/package.json

@@ -6,8 +6,7 @@
   "type": "module",
   "main": "dist/index.js",
   "exports": {
-    ".": "./dist/index.js",
-    "./public-api": "./dist/src/public-api.js"
+    ".": "./dist/index.js"
   },
   "bin": {
     "gemini": "dist/index.js"

packages/mcp-server/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "@google/gemini-mcp-server",
+  "name": "@gemini-community/gemini-mcp-server",
   "version": "0.1.8",
   "type": "module",
   "main": "dist/index.js",
@@ -21,11 +21,14 @@
     "prepublishOnly": "node ../../scripts/prepublish.js"
   },
   "dependencies": {
-    "@google/gemini-cli": "*",
     "@google/gemini-cli-core": "*",
     "@modelcontextprotocol/sdk": "^1.13.2",
+    "command-exists": "^1.2.9",
+    "dotenv": "^16.6.1",
     "express": "^5.1.0",
     "openai": "^5.8.2",
+    "read-package-up": "^11.0.0",
+    "strip-json-comments": "^3.1.1",
     "zod": "^3.23.8"
   },
   "devDependencies": {

packages/mcp-server/src/config/config.ts

@@ -0,0 +1,195 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import {
+  Config,
+  loadServerHierarchicalMemory,
+  setGeminiMdFilename as setServerGeminiMdFilename,
+  getCurrentGeminiMdFilename,
+  ApprovalMode,
+  GEMINI_CONFIG_DIR as GEMINI_DIR,
+  DEFAULT_GEMINI_MODEL,
+  DEFAULT_GEMINI_EMBEDDING_MODEL,
+  FileDiscoveryService,
+  TelemetryTarget,
+} from '@google/gemini-cli-core';
+import { Settings } from './settings.js';
+
+import { Extension } from './extension.js';
+import * as dotenv from 'dotenv';
+import * as fs from 'node:fs';
+import * as path from 'node:path';
+import * as os from 'node:os';
+import { loadSandboxConfig } from './sandboxConfig.js';
+
+// Simple console logger for now - replace with actual logger if available
+const logger = {
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  debug: (...args: any[]) => console.debug('[DEBUG]', ...args),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  warn: (...args: any[]) => console.warn('[WARN]', ...args),
+  // eslint-disable-next-line @typescript-eslint/no-explicit-any
+  error: (...args: any[]) => console.error('[ERROR]', ...args),
+};
+
+// This function is now a thin wrapper around the server's implementation.
+// It's kept in the CLI for now as App.tsx directly calls it for memory refresh.
+// TODO: Consider if App.tsx should get memory via a server call or if Config should refresh itself.
+export async function loadHierarchicalGeminiMemory(
+  currentWorkingDirectory: string,
+  debugMode: boolean,
+  fileService: FileDiscoveryService,
+  extensionContextFilePaths: string[] = [],
+): Promise<{ memoryContent: string; fileCount: number }> {
+  if (debugMode) {
+    logger.debug(
+      `CLI: Delegating hierarchical memory load to server for CWD: ${currentWorkingDirectory}`,
+    );
+  }
+  // Directly call the server function.
+  // The server function will use its own homedir() for the global path.
+  return loadServerHierarchicalMemory(
+    currentWorkingDirectory,
+    debugMode,
+    fileService,
+    extensionContextFilePaths,
+  );
+}
+
+export async function loadServerConfig(
+  settings: Settings,
+  extensions: Extension[],
+  sessionId: string,
+  debugMode: boolean,
+): Promise<Config> {
+  loadEnvironment();
+
+  // Set the context filename in the server's memoryTool module BEFORE loading memory
+  // TODO(b/343434939): This is a bit of a hack. The contextFileName should ideally be passed
+  // directly to the Config constructor in core, and have core handle setGeminiMdFilename.
+  // However, loadHierarchicalGeminiMemory is called *before* createServerConfig.
+  if (settings.contextFileName) {
+    setServerGeminiMdFilename(settings.contextFileName);
+  } else {
+    // Reset to default if not provided in settings.
+    setServerGeminiMdFilename(getCurrentGeminiMdFilename());
+  }
+
+  const extensionContextFilePaths = extensions.flatMap((e) => e.contextFiles);
+
+  const fileService = new FileDiscoveryService(process.cwd());
+  // Call the (now wrapper) loadHierarchicalGeminiMemory which calls the server's version
+  const { memoryContent, fileCount } = await loadHierarchicalGeminiMemory(
+    process.cwd(),
+    debugMode,
+    fileService,
+    extensionContextFilePaths,
+  );
+
+  const mcpServers = mergeMcpServers(settings, extensions);
+
+  const sandboxConfig = await loadSandboxConfig(settings, {});
+
+  return new Config({
+    sessionId,
+    embeddingModel: DEFAULT_GEMINI_EMBEDDING_MODEL,
+    sandbox: sandboxConfig,
+    targetDir: process.cwd(),
+    debugMode,
+    question: undefined,
+    fullContext: false,
+    coreTools: settings.coreTools || undefined,
+    excludeTools: settings.excludeTools || undefined,
+    toolDiscoveryCommand: settings.toolDiscoveryCommand,
+    toolCallCommand: settings.toolCallCommand,
+    mcpServerCommand: settings.mcpServerCommand,
+    mcpServers,
+    userMemory: memoryContent,
+    geminiMdFileCount: fileCount,
+    approvalMode: ApprovalMode.YOLO,
+    showMemoryUsage: settings.showMemoryUsage || false,
+    accessibility: settings.accessibility,
+    telemetry: {
+      enabled: settings.telemetry?.enabled,
+      target: settings.telemetry?.target as TelemetryTarget,
+      otlpEndpoint:
+        process.env.OTEL_EXPORTER_OTLP_ENDPOINT ??
+        settings.telemetry?.otlpEndpoint,
+      logPrompts: settings.telemetry?.logPrompts,
+    },
+    usageStatisticsEnabled: settings.usageStatisticsEnabled ?? true,
+    // Git-aware file filtering settings
+    fileFiltering: {
+      respectGitIgnore: settings.fileFiltering?.respectGitIgnore,
+      enableRecursiveFileSearch:
+        settings.fileFiltering?.enableRecursiveFileSearch,
+    },
+    checkpointing: settings.checkpointing?.enabled,
+    proxy:
+      process.env.HTTPS_PROXY ||
+      process.env.https_proxy ||
+      process.env.HTTP_PROXY ||
+      process.env.http_proxy,
+    cwd: process.cwd(),
+    fileDiscoveryService: fileService,
+    bugCommand: settings.bugCommand,
+    model: process.env.GEMINI_MODEL || DEFAULT_GEMINI_MODEL,
+    extensionContextFilePaths,
+  });
+}
+
+function mergeMcpServers(settings: Settings, extensions: Extension[]) {
+  const mcpServers = { ...(settings.mcpServers || {}) };
+  for (const extension of extensions) {
+    Object.entries(extension.config.mcpServers || {}).forEach(
+      ([key, server]) => {
+        if (mcpServers[key]) {
+          logger.warn(
+            `Skipping extension MCP config for server with key "${key}" as it already exists.`,
+          );
+          return;
+        }
+        mcpServers[key] = server;
+      },
+    );
+  }
+  return mcpServers;
+}
+function findEnvFile(startDir: string): string | null {
+  let currentDir = path.resolve(startDir);
+  while (true) {
+    // prefer gemini-specific .env under GEMINI_DIR
+    const geminiEnvPath = path.join(currentDir, GEMINI_DIR, '.env');
+    if (fs.existsSync(geminiEnvPath)) {
+      return geminiEnvPath;
+    }
+    const envPath = path.join(currentDir, '.env');
+    if (fs.existsSync(envPath)) {
+      return envPath;
+    }
+    const parentDir = path.dirname(currentDir);
+    if (parentDir === currentDir || !parentDir) {
+      // check .env under home as fallback, again preferring gemini-specific .env
+      const homeGeminiEnvPath = path.join(os.homedir(), GEMINI_DIR, '.env');
+      if (fs.existsSync(homeGeminiEnvPath)) {
+        return homeGeminiEnvPath;
+      }
+      const homeEnvPath = path.join(os.homedir(), '.env');
+      if (fs.existsSync(homeEnvPath)) {
+        return homeEnvPath;
+      }
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+
+export function loadEnvironment(): void {
+  const envFilePath = findEnvFile(process.cwd());
+  if (envFilePath) {
+    dotenv.config({ path: envFilePath, quiet: true });
+  }
+}

packages/mcp-server/src/config/extension.ts

@@ -0,0 +1,115 @@
+/**
+ * @license
+ * Copyright 2025 Google LLC
+ * SPDX-License-Identifier: Apache-2.0
+ */
+
+import { MCPServerConfig } from '@google/gemini-cli-core';
+import * as fs from 'fs';
+import * as path from 'path';
+import * as os from 'os';
+
+export const EXTENSIONS_DIRECTORY_NAME = path.join('.gemini', 'extensions');
+export const EXTENSIONS_CONFIG_FILENAME = 'gemini-extension.json';
+
+export interface Extension {
+  config: ExtensionConfig;
+  contextFiles: string[];
+}
+
+export interface ExtensionConfig {
+  name: string;
+  version: string;
+  mcpServers?: Record<string, MCPServerConfig>;
+  contextFileName?: string | string[];
+}
+
+export function loadExtensions(workspaceDir: string): Extension[] {
+  const allExtensions = [
+    ...loadExtensionsFromDir(workspaceDir),
+    ...loadExtensionsFromDir(os.homedir()),
+  ];
+
+  const uniqueExtensions: Extension[] = [];
+  const seenNames = new Set<string>();
+  for (const extension of allExtensions) {
+    if (!seenNames.has(extension.config.name)) {
+      console.log(
+        `Loading extension: ${extension.config.name} (version: ${extension.config.version})`,
+      );
+      uniqueExtensions.push(extension);
+      seenNames.add(extension.config.name);
+    }
+  }
+
+  return uniqueExtensions;
+}
+
+function loadExtensionsFromDir(dir: string): Extension[] {
+  const extensionsDir = path.join(dir, EXTENSIONS_DIRECTORY_NAME);
+  if (!fs.existsSync(extensionsDir)) {
+    return [];
+  }
+
+  const extensions: Extension[] = [];
+  for (const subdir of fs.readdirSync(extensionsDir)) {
+    const extensionDir = path.join(extensionsDir, subdir);
+
+    const extension = loadExtension(extensionDir);
+    if (extension != null) {
+      extensions.push(extension);
+    }
+  }
+  return extensions;
+}
+
+function loadExtension(extensionDir: string): Extension | null {
+  if (!fs.statSync(extensionDir).isDirectory()) {
+    console.error(
+      `Warning: unexpected file ${extensionDir} in extensions directory.`,
+    );
+    return null;
+  }
+
+  const configFilePath = path.join(extensionDir, EXTENSIONS_CONFIG_FILENAME);
+  if (!fs.existsSync(configFilePath)) {
+    console.error(
+      `Warning: extension directory ${extensionDir} does not contain a config file ${configFilePath}.`,
+    );
+    return null;
+  }
+
+  try {
+    const configContent = fs.readFileSync(configFilePath, 'utf-8');
+    const config = JSON.parse(configContent) as ExtensionConfig;
+    if (!config.name || !config.version) {
+      console.error(
+        `Invalid extension config in ${configFilePath}: missing name or version.`,
+      );
+      return null;
+    }
+
+    const contextFiles = getContextFileNames(config)
+      .map((contextFileName) => path.join(extensionDir, contextFileName))
+      .filter((contextFilePath) => fs.existsSync(contextFilePath));
+
+    return {
+      config,
+      contextFiles,
+    };
+  } catch (e) {
+    console.error(
+      `Warning: error parsing extension config in ${configFilePath}: ${e}`,
+    );
+    return null;
+  }
+}
+
+function getContextFileNames(config: ExtensionConfig): string[] {
+  if (!config.contextFileName) {
+    return ['GEMINI.md'];
+  } else if (!Array.isArray(config.contextFileName)) {
+    return [config.contextFileName];
+  }
+  return config.contextFileName;
+}