@yancyyu/openhermit 1.6.29 → 1.6.31

package/src/main/server.ts

@@ -48,6 +48,7 @@ import {
   CROSS_TEAM_SOURCE,
   formatCrossTeamText,
 } from '@shared/constants/crossTeam';
+import type { CcAgentType } from '../shared/types/ccConnect';
 import { CcConnectBridge } from './services/ccConnect/CcConnectBridge';
 import { CcConnectClient } from './services/ccConnect/CcConnectClient';
 import { TeamProvisioningService } from './services/teams-mvp';
@@ -231,7 +232,11 @@ async function initializeTaskBusFromSettings(): Promise<void> {
   }
 
   taskDispatch.dispose();
-  await taskDispatch.start(config);
+  try {
+    await taskDispatch.start(config);
+  } catch (err) {
+    app.log.warn({ err }, 'Redis connection failed on startup — task bus disabled');
+  }
 }
 
 function normalizeStringArray(value: unknown): string[] {
@@ -4617,7 +4622,8 @@ app.get('/api/telemetry/status', async (request, reply) => {
       // no settings
     }
     const taskBus = (settings.taskBus ?? {}) as TaskBusConfig;
-    const status = await getTelemetryStatus(taskBus.redis);
+    const redisCfg = taskBus.enabled ? taskBus.redis : undefined;
+    const status = await getTelemetryStatus(redisCfg);
     return (
       status ?? {
         connected: false,
@@ -4727,10 +4733,207 @@ app.get('/api/events', (request, reply) => {
 
 const SSE_FALLBACK_RE = /^\/api\/(.*\/(events|stream|notifications\/stream))$/;
 
-app.get('/api/extensions/mcp/browse', async () => ({
-  servers: [],
-  items: [],
-}));
+// ── Extension Store routes (wired to extensionHandlers) ────────────────
+
+import { extensionHandlers as ext, setSkillsWatcherEmitter } from './ipc/extensions';
+
+// Broadcast skill file-watcher changes to connected frontends via SSE.
+setSkillsWatcherEmitter((event) => broadcastSse('skills:changed', event));
+
+app.get('/api/extensions/plugins', async () => {
+  const result = await ext.pluginGetAll();
+  return result;
+});
+
+app.get('/api/extensions/plugins/readme/:pluginId', async (request) => {
+  const { pluginId } = request.params as { pluginId: string };
+  const result = await ext.pluginGetReadme(pluginId);
+  return result;
+});
+
+app.post('/api/extensions/plugins/install', async (request) => {
+  const body = request.body as Record<string, unknown>;
+  const result = await ext.pluginInstall(body as any);
+  return result;
+});
+
+app.post('/api/extensions/plugins/uninstall', async (request) => {
+  const body = request.body as Record<string, unknown>;
+  const result = await ext.pluginUninstall(
+    body.pluginId as string,
+    body.scope as string,
+    body.projectPath as string,
+    body.harnessType as CcAgentType | undefined
+  );
+  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);
+  return result;
+});
+
+app.post('/api/extensions/mcp/uninstall', async (request) => {
+  const body = request.body as Record<string, unknown>;
+  const result = await ext.mcpUninstall(
+    body.name as string,
+    body.scope as string,
+    body.projectPath as string,
+    body.harnessType as CcAgentType | undefined
+  );
+  return result;
+});
+
+app.get('/api/extensions/skills', async (request) => {
+  const projectPath = (request.query as Record<string, string>).projectPath;
+  const result = await ext.skillsList(projectPath);
+  return result;
+});
+
+app.get('/api/extensions/skills/:skillId', async (request) => {
+  const { skillId } = request.params as { skillId: string };
+  const projectPath = (request.query as Record<string, string>).projectPath;
+  const result = await ext.skillsGetDetail(skillId, projectPath);
+  return result;
+});
+
+app.post('/api/extensions/skills/upsert', async (request) => {
+  const result = await ext.skillsUpsert(request.body as any);
+  return result;
+});
+
+app.post('/api/extensions/skills/delete', async (request) => {
+  const result = await ext.skillsDelete(request.body as any);
+  return result;
+});
+
+app.post('/api/extensions/skills/preview-upsert', async (request) => {
+  return ext.skillsPreviewUpsert(request.body as any);
+});
+
+app.post('/api/extensions/skills/apply-upsert', async (request) => {
+  return ext.skillsApplyUpsert(request.body as any);
+});
+
+app.post('/api/extensions/skills/preview-import', async (request) => {
+  return ext.skillsPreviewImport(request.body as any);
+});
+
+app.post('/api/extensions/skills/apply-import', async (request) => {
+  return ext.skillsApplyImport(request.body as any);
+});
+
+app.post('/api/extensions/skills/watching/start', async (request) => {
+  const projectPath = (request.query as Record<string, string>).projectPath;
+  return ext.skillsStartWatching(projectPath);
+});
+
+app.post('/api/extensions/skills/watching/stop', async (request) => {
+  const { watchId } = (request.body ?? {}) as { watchId?: string };
+  return ext.skillsStopWatching(watchId as string);
+});
+
+app.get('/api/extensions/credentials/status', async () => {
+  const result = await ext.credentialsStatus();
+  return result;
+});
+
+app.get('/api/extensions/credentials/mcp/:mcpName', async (request) => {
+  const { mcpName } = request.params as { mcpName: string };
+  const result = await ext.credentialsGetMcp(mcpName);
+  return result;
+});
+
+app.post('/api/extensions/credentials/mcp', async (request) => {
+  const body = request.body as Record<string, unknown>;
+  const result = await ext.credentialsSaveMcp(
+    body.mcpName as string,
+    body.envValues as Record<string, string>
+  );
+  return result;
+});
+
+app.get('/api/extensions/credentials/project-env', async (request) => {
+  const projectPath = (request.query as Record<string, string>).projectPath;
+  if (!projectPath) return { error: 'projectPath required' };
+  const result = await ext.credentialsGetProjectEnv(projectPath);
+  return result;
+});
+
+app.post('/api/extensions/credentials/project-env', async (request) => {
+  const body = request.body as Record<string, unknown>;
+  const result = await ext.credentialsSaveProjectEnv(
+    body.projectPath as string,
+    body.vars as Record<string, string>
+  );
+  return result;
+});
+
+app.post('/api/extensions/credentials/scan-required', async (request) => {
+  const body = request.body as Record<string, unknown>;
+  const result = await ext.credentialsScanRequired(
+    body.projectPath as string,
+    body.mcpServers as any,
+    body.skillReqs as any
+  );
+  return result;
+});
+
+app.get('/api/extensions/credentials/resolve-agent-env', async (request) => {
+  const projectPath = (request.query as Record<string, string>).projectPath;
+  if (!projectPath) return { error: 'projectPath required' };
+  const result = await ext.credentialsResolveAgentEnv(projectPath);
+  return result;
+});
+
+app.get('/api/extensions/credentials/skill-env', async (request) => {
+  const folderName = (request.query as Record<string, string>).folderName;
+  if (!folderName) return { error: 'folderName required' };
+  const result = await ext.credentialsGetSkillGlobalEnv(folderName);
+  return result;
+});
+
+app.post('/api/extensions/credentials/skill-env', async (request) => {
+  const body = request.body as Record<string, unknown>;
+  const result = await ext.credentialsSaveSkillGlobalEnv(
+    body.folderName as string,
+    body.vars as Record<string, string>
+  );
+  return result;
+});
 
 app.setNotFoundHandler((request, reply) => {
   const u = request.url;

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;
+  }
+}