@yancyyu/openhermit 1.6.28 → 1.6.30

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

@@ -0,0 +1,135 @@
+/**
+ * Facade service that combines plugin catalog + MCP 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).
+ */
+
+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';
+
+const logger = createLogger('Extensions:Facade');
+
+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 ───────────────────────────────────────────────────
+
+  /**
+   * Get all plugins enriched with install status and counts.
+   */
+  async getEnrichedPlugins(projectPath?: string, forceRefresh = false): Promise<EnrichedPlugin[]> {
+    const [catalog, installed, counts] = await Promise.all([
+      this.pluginCatalog.getPlugins(forceRefresh),
+      this.pluginState.getInstalledPlugins(projectPath),
+      this.pluginState.getInstallCounts(),
+    ]);
+
+    // Build installed lookup: pluginId → entries[]
+    const installedMap = new Map<string, typeof installed>();
+    for (const entry of installed) {
+      const list = installedMap.get(entry.pluginId) ?? [];
+      list.push(entry);
+      installedMap.set(entry.pluginId, list);
+    }
+
+    return catalog.map((item): EnrichedPlugin => {
+      const installations = installedMap.get(item.pluginId) ?? [];
+      const installCount = counts.get(item.pluginId) ?? 0;
+
+      return {
+        ...item,
+        installCount,
+        isInstalled: installations.length > 0,
+        installations,
+      };
+    });
+  }
+
+  /**
+   * Get README content for a plugin.
+   */
+  async getPluginReadme(pluginId: string): Promise<string | null> {
+    return this.pluginCatalog.getPluginReadme(pluginId);
+  }
+
+  /**
+   * Resolve a pluginId to its install target.
+   */
+  async resolvePluginInstallTarget(
+    pluginId: string
+  ): Promise<{ qualifiedName: string; plugin: PluginCatalogItem } | null> {
+    const plugin = await this.pluginCatalog.resolvePlugin(pluginId);
+    if (!plugin) {
+      logger.warn(`Cannot resolve install target: pluginId "${pluginId}" not found in catalog`);
+      return null;
+    }
+    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/catalog/GlamaMcpEnrichmentService.ts

@@ -0,0 +1,190 @@
+/**
+ * Fetches MCP server data from the Glama.ai API.
+ *
+ * Optional enrichment layer — NOT a hard dependency.
+ * Provides: license, tools, Glama URL.
+ * Does NOT provide install info (no packages/remotes).
+ *
+ * Base URL: https://glama.ai/api/mcp/v1/servers
+ * Cursor-based pagination (after), no auth required.
+ */
+
+import http from 'node:http';
+import https from 'node:https';
+
+import { createLogger } from '@shared/utils/logger';
+
+import type { McpCatalogItem, McpHostingType, McpToolDef } from '@shared/types/extensions';
+
+const logger = createLogger('Extensions:GlamaMcp');
+
+// ── Constants ──────────────────────────────────────────────────────────────
+
+const GLAMA_BASE_URL = 'https://glama.ai/api/mcp/v1/servers';
+const HTTP_TIMEOUT_MS = 15_000;
+const MAX_REDIRECTS = 5;
+const MAX_BODY_SIZE = 10 * 1024 * 1024; // 10MB safety limit
+
+// ── HTTP helper ────────────────────────────────────────────────────────────
+
+function httpGet(
+  url: string,
+  redirectsLeft = MAX_REDIRECTS
+): Promise<{ statusCode: number; body: string }> {
+  return new Promise((resolve, reject) => {
+    const parsedUrl = new URL(url);
+    const transport = parsedUrl.protocol === 'http:' ? http : https;
+    let settled = false;
+
+    const settleResolve = (v: { statusCode: number; body: string }): void => {
+      if (!settled) {
+        settled = true;
+        resolve(v);
+      }
+    };
+    const settleReject = (e: Error): void => {
+      if (!settled) {
+        settled = true;
+        reject(e);
+      }
+    };
+
+    const req = transport.get(url, (res) => {
+      const status = res.statusCode ?? 0;
+      if (status >= 300 && status < 400 && res.headers.location) {
+        if (redirectsLeft <= 0) {
+          res.destroy();
+          settleReject(new Error('Too many redirects'));
+          return;
+        }
+        res.destroy();
+        httpGet(new URL(res.headers.location, url).toString(), redirectsLeft - 1).then(
+          settleResolve,
+          settleReject
+        );
+        return;
+      }
+      const chunks: Buffer[] = [];
+      let totalSize = 0;
+      res.on('data', (c: Buffer) => {
+        totalSize += c.length;
+        if (totalSize > MAX_BODY_SIZE) {
+          res.destroy(new Error(`Response body exceeds ${MAX_BODY_SIZE} bytes`));
+          return;
+        }
+        chunks.push(c);
+      });
+      res.on('end', () =>
+        settleResolve({ statusCode: status, body: Buffer.concat(chunks).toString('utf-8') })
+      );
+      res.on('error', settleReject);
+    });
+    req.setTimeout(HTTP_TIMEOUT_MS, () => req.destroy(new Error(`Timeout fetching ${url}`)));
+    req.on('error', (e) => settleReject(e instanceof Error ? e : new Error(String(e))));
+  });
+}
+
+// ── Raw Glama API shapes ───────────────────────────────────────────────────
+
+interface GlamaResponse {
+  pageInfo: {
+    endCursor?: string;
+    hasNextPage?: boolean;
+  };
+  servers: GlamaServer[];
+}
+
+interface GlamaServer {
+  id: string;
+  name: string;
+  namespace?: string;
+  description?: string;
+  slug?: string;
+  url?: string;
+  repository?: { url: string };
+  spdxLicense?: { name: string; url?: string } | null;
+  tools?: { name?: string; description?: string }[];
+  attributes?: string[];
+}
+
+// ── Service ────────────────────────────────────────────────────────────────
+
+export class GlamaMcpEnrichmentService {
+  /**
+   * Search Glama for MCP servers.
+   */
+  async search(query: string, limit = 20): Promise<McpCatalogItem[]> {
+    const params = new URLSearchParams({ search: query, first: String(limit) });
+    const url = `${GLAMA_BASE_URL}?${params}`;
+
+    try {
+      const resp = await httpGet(url);
+      if (resp.statusCode !== 200) throw new Error(`HTTP ${resp.statusCode}`);
+      const json = JSON.parse(resp.body) as GlamaResponse;
+      return json.servers.map((s) => this.normalize(s));
+    } catch (err) {
+      logger.warn('Glama MCP search failed:', err);
+      return [];
+    }
+  }
+
+  /**
+   * Browse Glama catalog with cursor pagination.
+   */
+  async browse(
+    cursor?: string,
+    limit = 20
+  ): Promise<{ servers: McpCatalogItem[]; nextCursor?: string }> {
+    const params = new URLSearchParams({ first: String(limit) });
+    if (cursor) params.set('after', cursor);
+    const url = `${GLAMA_BASE_URL}?${params}`;
+
+    try {
+      const resp = await httpGet(url);
+      if (resp.statusCode !== 200) throw new Error(`HTTP ${resp.statusCode}`);
+      const json = JSON.parse(resp.body) as GlamaResponse;
+      return {
+        servers: json.servers.map((s) => this.normalize(s)),
+        nextCursor: json.pageInfo.hasNextPage ? json.pageInfo.endCursor : undefined,
+      };
+    } catch (err) {
+      logger.warn('Glama MCP browse failed:', err);
+      return { servers: [] };
+    }
+  }
+
+  // ── Private ────────────────────────────────────────────────────────────
+
+  private normalize(raw: GlamaServer): McpCatalogItem {
+    const tools: McpToolDef[] = (raw.tools ?? [])
+      .filter((t): t is { name: string; description: string } => Boolean(t.name))
+      .map((t) => ({ name: t.name, description: t.description ?? '' }));
+
+    return {
+      id: `glama:${raw.id}`,
+      name: raw.name,
+      description: raw.description ?? '',
+      repositoryUrl: raw.repository?.url,
+      version: undefined, // Glama doesn't expose version
+      source: 'glama',
+      installSpec: null, // Glama has NO install info
+      envVars: [],
+      license: raw.spdxLicense?.name,
+      tools,
+      glamaUrl: raw.url,
+      requiresAuth: false,
+      author: raw.namespace,
+      hostingType: this.deriveHostingType(raw.attributes),
+    };
+  }
+
+  private deriveHostingType(attributes?: string[]): McpHostingType | undefined {
+    if (!attributes?.length) return undefined;
+    const hasLocal = attributes.includes('hosting:local-only');
+    const hasRemote = attributes.includes('hosting:remote-capable');
+    if (hasLocal && hasRemote) return 'both';
+    if (hasLocal) return 'local';
+    if (hasRemote) return 'remote';
+    return undefined;
+  }
+}

package/src/main/services/extensions/catalog/McpCatalogAggregator.ts

@@ -0,0 +1,150 @@
+/**
+ * Aggregates MCP catalog data from Official Registry + Glama.
+ *
+ * - Uses Promise.allSettled so partial API failures don't break the whole catalog
+ * - Dedup by repository URL; Official source takes priority
+ * - Enriches Official entries with Glama data (license, tools) when matched
+ * - Provides getById() for secure install flow
+ */
+
+import { normalizeRepoUrl } from '@shared/utils/extensionNormalizers';
+import { createLogger } from '@shared/utils/logger';
+
+import { type GlamaMcpEnrichmentService } from './GlamaMcpEnrichmentService';
+import { type OfficialMcpRegistryService } from './OfficialMcpRegistryService';
+
+import type { McpCatalogItem, McpSearchResult } from '@shared/types/extensions';
+
+const logger = createLogger('Extensions:McpAggregator');
+
+export class McpCatalogAggregator {
+  constructor(
+    private readonly official: OfficialMcpRegistryService,
+    private readonly glama: GlamaMcpEnrichmentService
+  ) {}
+
+  /**
+   * Search both sources and return merged results.
+   */
+  async search(query: string, limit = 20): Promise<McpSearchResult> {
+    const warnings: string[] = [];
+
+    const [officialResult, glamaResult] = await Promise.allSettled([
+      this.official.search(query, limit),
+      this.glama.search(query, limit),
+    ]);
+
+    const officialServers = officialResult.status === 'fulfilled' ? officialResult.value : [];
+    const glamaServers = glamaResult.status === 'fulfilled' ? glamaResult.value : [];
+
+    if (officialResult.status === 'rejected') {
+      warnings.push('Official MCP Registry unavailable');
+      logger.warn('Official registry search failed:', officialResult.reason);
+    }
+    if (glamaResult.status === 'rejected') {
+      warnings.push('Glama enrichment unavailable');
+      logger.warn('Glama search failed:', glamaResult.reason);
+    }
+
+    const merged = this.mergeAndDeduplicate(officialServers, glamaServers);
+
+    return { servers: merged, warnings };
+  }
+
+  /**
+   * Browse the official registry with optional Glama enrichment.
+   */
+  async browse(
+    cursor?: string,
+    limit = 20
+  ): Promise<{ servers: McpCatalogItem[]; nextCursor?: string }> {
+    // Browse primarily from official registry (has pagination)
+    const result = await this.official.browse(cursor, limit);
+
+    // Optionally enrich with Glama data (best effort, no pagination sync)
+    try {
+      const glamaBrowse = await this.glama.browse(undefined, limit);
+      const enriched = this.enrichOfficialWithGlama(result.servers, glamaBrowse.servers);
+      return { servers: enriched, nextCursor: result.nextCursor };
+    } catch {
+      return result;
+    }
+  }
+
+  /**
+   * Get a single server by ID for secure install flow.
+   * Delegates to appropriate source based on ID prefix.
+   */
+  async getById(registryId: string): Promise<McpCatalogItem | null> {
+    // Glama IDs are prefixed with "glama:"
+    if (registryId.startsWith('glama:')) {
+      logger.warn(`Cannot install Glama-only server: ${registryId}`);
+      return null; // Glama servers can't be auto-installed
+    }
+
+    // Official registry lookup
+    return this.official.getById(registryId);
+  }
+
+  // ── Private ────────────────────────────────────────────────────────────
+
+  /**
+   * Merge Official + Glama, dedup by repository URL.
+   * Official entries take priority.
+   */
+  private mergeAndDeduplicate(
+    official: McpCatalogItem[],
+    glama: McpCatalogItem[]
+  ): McpCatalogItem[] {
+    // Build repo URL index from official entries
+    const officialRepoUrls = new Set<string>();
+    for (const item of official) {
+      if (item.repositoryUrl) {
+        officialRepoUrls.add(normalizeRepoUrl(item.repositoryUrl));
+      }
+    }
+
+    // Enrich official entries with Glama data
+    const enriched = this.enrichOfficialWithGlama(official, glama);
+
+    // Add Glama-only entries (no matching official entry)
+    const glamaOnly = glama.filter((g) => {
+      if (!g.repositoryUrl) return true; // no repo URL = can't match, show separately
+      return !officialRepoUrls.has(normalizeRepoUrl(g.repositoryUrl));
+    });
+
+    return [...enriched, ...glamaOnly];
+  }
+
+  /**
+   * Enrich official entries with Glama metadata (license, tools, glamaUrl).
+   */
+  private enrichOfficialWithGlama(
+    official: McpCatalogItem[],
+    glama: McpCatalogItem[]
+  ): McpCatalogItem[] {
+    // Index Glama by normalized repo URL
+    const glamaByRepo = new Map<string, McpCatalogItem>();
+    for (const g of glama) {
+      if (g.repositoryUrl) {
+        glamaByRepo.set(normalizeRepoUrl(g.repositoryUrl), g);
+      }
+    }
+
+    return official.map((item) => {
+      if (!item.repositoryUrl) return item;
+
+      const glamaMatch = glamaByRepo.get(normalizeRepoUrl(item.repositoryUrl));
+      if (!glamaMatch) return item;
+
+      return {
+        ...item,
+        license: item.license ?? glamaMatch.license,
+        tools: item.tools.length > 0 ? item.tools : glamaMatch.tools,
+        glamaUrl: glamaMatch.glamaUrl,
+        author: item.author ?? glamaMatch.author,
+        hostingType: item.hostingType ?? glamaMatch.hostingType,
+      };
+    });
+  }
+}