@yancyyu/openhermit 1.6.36 → 1.6.38

package/src/main/server.ts

@@ -4768,38 +4768,12 @@ app.post('/api/extensions/plugins/uninstall', async (request) => {
   return result;
 });
 
-app.get('/api/extensions/mcp/search', async (request) => {
-  const query = (request.query as Record<string, string>).q ?? '';
-  const limit = Number((request.query as Record<string, string>).limit) || 20;
-  const result = await ext.mcpSearch(query, limit);
-  return result;
-});
-
-app.get('/api/extensions/mcp/browse', async (request) => {
-  const cursor = (request.query as Record<string, string>).cursor;
-  const limit = Number((request.query as Record<string, string>).limit) || 20;
-  const result = await ext.mcpBrowse(cursor || undefined, limit);
-  return result;
-});
-
 app.get('/api/extensions/mcp/installed', async (request) => {
   const projectPath = (request.query as Record<string, string>).projectPath;
   const result = await ext.mcpGetInstalled(projectPath);
   return result;
 });
 
-app.get('/api/extensions/mcp/:registryId', async (request) => {
-  const { registryId } = request.params as { registryId: string };
-  const result = await ext.mcpGetById(registryId);
-  return result;
-});
-
-app.post('/api/extensions/mcp/install', async (request) => {
-  const body = request.body as Record<string, unknown>;
-  const result = await ext.mcpInstall(body as any);
-  return result;
-});
-
 app.post('/api/extensions/mcp/install-custom', async (request) => {
   const body = request.body as Record<string, unknown>;
   const result = await ext.mcpInstallCustom(body as any);
@@ -4817,6 +4791,23 @@ app.post('/api/extensions/mcp/uninstall', async (request) => {
   return result;
 });
 
+app.get('/api/extensions/mcp/library', async () => {
+  return ext.mcpLibraryList();
+});
+
+app.post('/api/extensions/mcp/library', async (request) => {
+  return ext.mcpLibraryUpsert(request.body as any);
+});
+
+app.delete('/api/extensions/mcp/library/:id', async (request) => {
+  const { id } = request.params as { id: string };
+  return ext.mcpLibraryDelete(id);
+});
+
+app.post('/api/extensions/mcp/library/import', async (request) => {
+  return ext.mcpLibraryImport((request.body ?? {}) as any);
+});
+
 app.get('/api/extensions/skills', async (request) => {
   const projectPath = (request.query as Record<string, string>).projectPath;
   const result = await ext.skillsList(projectPath);

package/src/main/services/extensions/ExtensionFacadeService.ts

@@ -1,23 +1,18 @@
 /**
- * Facade service that combines plugin catalog + MCP catalog + installation state
+ * Facade service that combines plugin catalog + installation state
  * into enriched data ready for the renderer.
  *
  * Also provides install target resolution for the security model
- * (main-side re-resolution: renderer sends pluginId/registryId, main resolves from catalog).
+ * (main-side re-resolution: renderer sends pluginId, main resolves from catalog).
  */
 
 import { createLogger } from '@shared/utils/logger';
 
-import { type McpCatalogAggregator } from './catalog/McpCatalogAggregator';
 import { type PluginCatalogService } from './catalog/PluginCatalogService';
-import { type McpInstallationStateService } from './state/McpInstallationStateService';
 import { type PluginInstallationStateService } from './state/PluginInstallationStateService';
 
 import type {
   EnrichedPlugin,
-  InstalledMcpEntry,
-  McpCatalogItem,
-  McpSearchResult,
   PluginCatalogItem,
 } from '@shared/types/extensions';
 
@@ -27,8 +22,6 @@ export class ExtensionFacadeService {
   constructor(
     private readonly pluginCatalog: PluginCatalogService,
     private readonly pluginState: PluginInstallationStateService,
-    private readonly mcpAggregator: McpCatalogAggregator | null = null,
-    private readonly mcpState: McpInstallationStateService | null = null
   ) {}
 
   // ── Plugin methods ───────────────────────────────────────────────────
@@ -85,51 +78,9 @@ export class ExtensionFacadeService {
     return { qualifiedName: plugin.qualifiedName, plugin };
   }
 
-  // ── MCP methods ──────────────────────────────────────────────────────
-
-  /**
-   * Search MCP servers across both registries.
-   */
-  async searchMcp(query: string, limit?: number): Promise<McpSearchResult> {
-    if (!this.mcpAggregator) {
-      return { servers: [], warnings: ['MCP catalog not configured'] };
-    }
-    return this.mcpAggregator.search(query, limit);
-  }
-
-  /**
-   * Browse MCP catalog with pagination.
-   */
-  async browseMcp(
-    cursor?: string,
-    limit?: number
-  ): Promise<{ servers: McpCatalogItem[]; nextCursor?: string }> {
-    if (!this.mcpAggregator) {
-      return { servers: [] };
-    }
-    return this.mcpAggregator.browse(cursor, limit);
-  }
-
-  /**
-   * Get a single MCP server by registry ID (for install flow).
-   */
-  async getMcpById(registryId: string): Promise<McpCatalogItem | null> {
-    if (!this.mcpAggregator) return null;
-    return this.mcpAggregator.getById(registryId);
-  }
-
-  /**
-   * Get installed MCP servers.
-   */
-  async getInstalledMcp(projectPath?: string): Promise<InstalledMcpEntry[]> {
-    if (!this.mcpState) return [];
-    return this.mcpState.getInstalled(projectPath);
-  }
-
   // ── Cache invalidation ───────────────────────────────────────────────
 
   invalidateInstalledCache(): void {
     this.pluginState.invalidateCache();
-    this.mcpState?.invalidateCache();
   }
 }

package/src/main/services/extensions/library/McpLibraryService.ts

@@ -0,0 +1,243 @@
+/**
+ * McpLibraryService — a reusable, global library of MCP server definitions.
+ *
+ * cc-switch model: a server is defined once and can be enabled for any worker
+ * (= installed into that worker's project config) without re-entering the
+ * command / URL / env each time. The "enable/disable for a worker" action is
+ * handled by the existing install/uninstall path; this service only owns the
+ * persisted library of definitions.
+ *
+ * Storage: ~/.hermit/mcp-library.json (HERMIT_HOME override respected).
+ */
+
+import * as fs from 'node:fs';
+import * as os from 'node:os';
+import * as path from 'node:path';
+import { randomUUID } from 'node:crypto';
+
+import { createLogger } from '@shared/utils/logger';
+import { getErrorMessage } from '@shared/utils/errorHandling';
+
+import { McpConfigStateReader } from '../runtime/McpConfigStateReader';
+
+import type {
+  McpHeaderDef,
+  McpInstallSpec,
+  McpLibraryEntry,
+  McpLibraryImportRequest,
+  McpLibraryImportResult,
+  McpLibraryUpsertRequest,
+} from '@shared/types/extensions';
+
+const logger = createLogger('Extensions:McpLibrary');
+
+function getHermitHome(): string {
+  return process.env.HERMIT_HOME ?? path.join(os.homedir(), '.hermit');
+}
+
+/**
+ * Best-effort mapping of a raw MCP server config (from ~/.claude.json /
+ * .mcp.json) into the install spec the current install path understands.
+ * Returns null when the config cannot be represented (e.g. an arbitrary stdio
+ * command rather than an npm package) — the caller skips those.
+ */
+function rawConfigToInstallSpec(config: Record<string, unknown>): McpInstallSpec | null {
+  const url = typeof config.url === 'string' ? config.url : null;
+  if (url) {
+    const rawType = typeof config.type === 'string' ? config.type : 'http';
+    const transportType =
+      rawType === 'sse' ? 'sse' : rawType === 'streamable-http' ? 'streamable-http' : 'http';
+    return { type: 'http', url, transportType };
+  }
+
+  const command = typeof config.command === 'string' ? config.command : null;
+  if (command) {
+    const args = Array.isArray(config.args) ? config.args.map(String) : [];
+    const npmPackage = extractNpmPackage(command, args);
+    if (npmPackage) {
+      return { type: 'stdio', npmPackage };
+    }
+  }
+
+  return null;
+}
+
+/** Pull the package spec out of `npx -y <pkg>` / `npm exec <pkg>` style commands. */
+function extractNpmPackage(command: string, args: string[]): string | null {
+  const base = path.basename(command);
+  if (base !== 'npx' && base !== 'npm' && base !== 'pnpm' && base !== 'bunx') {
+    return null;
+  }
+  // Skip flags (-y, --yes, exec, ...) and take the first package-looking token.
+  for (const arg of args) {
+    if (arg.startsWith('-')) continue;
+    if (arg === 'exec' || arg === 'dlx') continue;
+    return arg;
+  }
+  return null;
+}
+
+function extractEnvValues(config: Record<string, unknown>): Record<string, string> | undefined {
+  const env = config.env;
+  if (!env || typeof env !== 'object' || Array.isArray(env)) return undefined;
+  const out: Record<string, string> = {};
+  for (const [key, value] of Object.entries(env as Record<string, unknown>)) {
+    if (typeof value === 'string') out[key] = value;
+  }
+  return Object.keys(out).length > 0 ? out : undefined;
+}
+
+function extractHeaders(config: Record<string, unknown>): McpHeaderDef[] | undefined {
+  const headers = config.headers;
+  if (!headers || typeof headers !== 'object' || Array.isArray(headers)) return undefined;
+  const out: McpHeaderDef[] = [];
+  for (const [key, value] of Object.entries(headers as Record<string, unknown>)) {
+    if (typeof value === 'string') out.push({ key, value });
+  }
+  return out.length > 0 ? out : undefined;
+}
+
+export class McpLibraryService {
+  private readonly filePath: string;
+  private entries: McpLibraryEntry[] | null = null;
+
+  constructor(
+    dataDir: string = getHermitHome(),
+    private readonly stateReader = new McpConfigStateReader()
+  ) {
+    this.filePath = path.join(dataDir, 'mcp-library.json');
+  }
+
+  // ── Read ─────────────────────────────────────────────────────────────────
+
+  list(): McpLibraryEntry[] {
+    return [...this.load()].sort((a, b) => a.name.localeCompare(b.name));
+  }
+
+  // ── Write ──────────────────────────────────────────────────────────────────
+
+  upsert(request: McpLibraryUpsertRequest): McpLibraryEntry {
+    const name = request.name.trim();
+    if (!name) throw new Error('MCP 名称不能为空');
+
+    const entries = this.load();
+    const now = Date.now();
+
+    if (request.id) {
+      const existing = entries.find((e) => e.id === request.id);
+      if (!existing) throw new Error(`未找到库条目: ${request.id}`);
+      this.assertNameAvailable(entries, name, request.id);
+      existing.name = name;
+      existing.description = request.description?.trim() || undefined;
+      existing.installSpec = request.installSpec;
+      existing.envValues = request.envValues;
+      existing.headers = request.headers;
+      existing.updatedAt = now;
+      this.save(entries);
+      return existing;
+    }
+
+    this.assertNameAvailable(entries, name, null);
+    const entry: McpLibraryEntry = {
+      id: randomUUID(),
+      name,
+      description: request.description?.trim() || undefined,
+      installSpec: request.installSpec,
+      envValues: request.envValues,
+      headers: request.headers,
+      createdAt: now,
+      updatedAt: now,
+    };
+    entries.push(entry);
+    this.save(entries);
+    return entry;
+  }
+
+  remove(id: string): void {
+    const entries = this.load();
+    const next = entries.filter((e) => e.id !== id);
+    if (next.length !== entries.length) this.save(next);
+  }
+
+  /**
+   * Import MCP servers already present in live config into the library.
+   * Skips entries whose name already exists, and ones whose config can't be
+   * represented by the current install spec (e.g. arbitrary stdio commands).
+   */
+  async importFromLive(request: McpLibraryImportRequest): Promise<McpLibraryImportResult> {
+    const configured = await this.stateReader.readConfigured(request.projectPath);
+    const entries = this.load();
+    const existingNames = new Set(entries.map((e) => e.name.toLowerCase()));
+
+    const imported: string[] = [];
+    const skipped: string[] = [];
+    const now = Date.now();
+
+    for (const entry of configured) {
+      if (existingNames.has(entry.name.toLowerCase())) {
+        skipped.push(entry.name);
+        continue;
+      }
+      const installSpec = rawConfigToInstallSpec(entry.config);
+      if (!installSpec) {
+        skipped.push(entry.name);
+        continue;
+      }
+      entries.push({
+        id: randomUUID(),
+        name: entry.name,
+        installSpec,
+        envValues: extractEnvValues(entry.config),
+        headers: extractHeaders(entry.config),
+        createdAt: now,
+        updatedAt: now,
+      });
+      existingNames.add(entry.name.toLowerCase());
+      imported.push(entry.name);
+    }
+
+    if (imported.length > 0) this.save(entries);
+    return { imported, skipped };
+  }
+
+  // ── Private ──────────────────────────────────────────────────────────────
+
+  private assertNameAvailable(
+    entries: McpLibraryEntry[],
+    name: string,
+    ignoreId: string | null
+  ): void {
+    const clash = entries.find(
+      (e) => e.name.toLowerCase() === name.toLowerCase() && e.id !== ignoreId
+    );
+    if (clash) throw new Error(`库中已存在同名 MCP: ${name}`);
+  }
+
+  private load(): McpLibraryEntry[] {
+    if (this.entries) return this.entries;
+    try {
+      if (fs.existsSync(this.filePath)) {
+        const raw = fs.readFileSync(this.filePath, 'utf-8');
+        const parsed = JSON.parse(raw) as McpLibraryEntry[];
+        this.entries = Array.isArray(parsed) ? parsed : [];
+      } else {
+        this.entries = [];
+      }
+    } catch (error) {
+      logger.warn(`Failed to load MCP library from ${this.filePath}: ${getErrorMessage(error)}`);
+      this.entries = [];
+    }
+    return this.entries;
+  }
+
+  private save(entries: McpLibraryEntry[]): void {
+    this.entries = entries;
+    try {
+      const dir = path.dirname(this.filePath);
+      if (!fs.existsSync(dir)) fs.mkdirSync(dir, { recursive: true });
+      fs.writeFileSync(this.filePath, JSON.stringify(entries, null, 2), 'utf-8');
+    } catch (error) {
+      logger.warn(`Failed to save MCP library to ${this.filePath}: ${getErrorMessage(error)}`);
+    }
+  }
+}

package/src/main/services/session-intelligence/UsageTelemetryService.ts

@@ -26,6 +26,8 @@ function redisConfig(cfg: TaskBusConfig) {
     password: cfg.redis.password,
     db: cfg.redis.db,
     lazyConnect: true,
+    maxRetriesPerRequest: 0,
+    retryStrategy: () => null,
   };
 }
 
@@ -39,6 +41,9 @@ async function getRedis(cfg: TaskBusConfig): Promise<Redis | null> {
   }
 
   const r = new Redis(redisConfig(cfg));
+  r.on('error', () => {
+    /* handled by connect/ping fallback */
+  });
   try {
     await r.connect();
     await r.ping();
@@ -107,7 +112,7 @@ async function doScan(cfg: TaskBusConfig): Promise<ParseResult | null> {
   const result = await scanSessions();
   lastLocalScan = statusFromParseResult(result, false);
 
-  if (!cfg.telemetry.uploadEnabled) {
+  if (!cfg.enabled || !cfg.telemetry.uploadEnabled) {
     return result;
   }
 
@@ -212,10 +217,18 @@ export async function getTelemetryStatus(
 
   const cfg = { redis: redisCfg };
   const client = new Redis(redisConfig(cfg as TaskBusConfig));
+  client.on('error', () => {
+    /* handled by connect/ping fallback */
+  });
   try {
     await client.connect();
     await client.ping();
   } catch {
+    try {
+      client.disconnect();
+    } catch {
+      /* ignore */
+    }
     return lastLocalScan;
   }
 

package/src/main/services/teams-mvp/TaskDispatchService.ts

@@ -79,6 +79,7 @@ export class TaskDispatchService {
     this.stopHeartbeat();
     this.stopConsumers();
     this.stopResponseConsumers();
+    this.collabBoard.setRedis(null);
     this.redis?.disconnect();
     this.redisSub?.disconnect();
     this.redis = null;
@@ -757,27 +758,51 @@ export class TaskDispatchService {
 
   private async connectRedis(): Promise<void> {
     if (!this.config?.redis) return;
+    let redis: Redis | null = null;
+    let redisSub: Redis | null = null;
     try {
       const ioredis = await import('ioredis');
       const { host, port, password, db } = this.config.redis;
-      const opts = { host, port, password: password || undefined, db: db ?? 0 };
+      const opts = {
+        host,
+        port,
+        password: password || undefined,
+        db: db ?? 0,
+        lazyConnect: true,
+        maxRetriesPerRequest: 0,
+        retryStrategy: () => null,
+      };
 
-      this.redis = new ioredis.default(opts);
-      this.redisSub = new ioredis.default(opts);
+      redis = new ioredis.default(opts);
+      redisSub = new ioredis.default(opts);
 
-      this.redis.on('error', (err: Error) => {
-        console.error('[TaskDispatchService] Redis error:', err.message);
+      redis.on('error', (err: Error) => {
+        console.warn('[TaskDispatchService] Redis error:', err.message);
+      });
+      redisSub.on('error', (err: Error) => {
+        console.warn('[TaskDispatchService] Redis subscriber error:', err.message);
       });
 
-      await this.redis.ping();
+      await redis.connect();
+      await redisSub.connect();
+      await redis.ping();
 
+      this.redis = redis;
+      this.redisSub = redisSub;
+      redis = null;
+      redisSub = null;
       this.collabBoard.setRedis(this.redis);
       this.startHeartbeat();
       this.startConsumers();
       this.startResponseConsumers();
       this.subscribeStatus();
     } catch (err) {
-      console.error('[TaskDispatchService] Redis connect failed:', err);
+      console.warn('[TaskDispatchService] Redis connect failed:', err);
+      this.collabBoard.setRedis(null);
+      redis?.disconnect();
+      redisSub?.disconnect();
+      this.redis?.disconnect();
+      this.redisSub?.disconnect();
       this.redis = null;
       this.redisSub = null;
     }