@yancyyu/openhermit 1.6.29 → 1.6.31

package/src/main/services/extensions/runtime/GeminiAdapter.ts

@@ -0,0 +1,91 @@
+/**
+ * Gemini harness adapter — uses `gemini` CLI for MCP and skills.
+ */
+
+import { getHomeDir } from '@main/utils/pathDecoder';
+import type { CcAgentType } from '@shared/types/ccConnect';
+import path from 'node:path';
+
+import { ClaudeCodeAdapter } from './ClaudeCodeAdapter';
+
+import type {
+  HarnessInstallAdapter,
+  InstallOpts,
+  ResolvedSkillRoot,
+} from './HarnessInstallAdapter';
+import type {
+  InstalledMcpEntry,
+  InstalledPluginEntry,
+  McpHeaderDef,
+  McpInstallSpec,
+  OperationResult,
+} from '@shared/types/extensions';
+
+function resolveBinaryFromPath(binaryName: string): Promise<string | null> {
+  return new Promise((resolve) => {
+    import('node:child_process')
+      .then(({ execFile }) => {
+        execFile('which', [binaryName], { timeout: 5_000 }, (err, stdout) => {
+          resolve(err || !stdout?.trim() ? null : stdout.trim());
+        });
+      })
+      .catch(() => resolve(null));
+  });
+}
+
+export class GeminiAdapter implements HarnessInstallAdapter {
+  readonly harnessType: CcAgentType = 'gemini';
+  readonly supportsPlugins = false;
+  readonly supportsMcp = true;
+  readonly supportsSkills = true;
+
+  private readonly delegate = new ClaudeCodeAdapter();
+
+  async resolveBinary(): Promise<string | null> {
+    return resolveBinaryFromPath('gemini');
+  }
+
+  async installPlugin(): Promise<OperationResult> {
+    return { state: 'error', error: 'Gemini does not support Claude plugins' };
+  }
+  async uninstallPlugin(): Promise<OperationResult> {
+    return { state: 'error', error: 'Gemini does not support Claude plugins' };
+  }
+
+  async installMcp(
+    name: string,
+    spec: McpInstallSpec,
+    envValues: Record<string, string>,
+    headers: McpHeaderDef[],
+    opts: InstallOpts
+  ): Promise<OperationResult> {
+    return this.delegate.installMcp(name, spec, envValues, headers, opts);
+  }
+
+  async uninstallMcp(name: string, opts: InstallOpts): Promise<OperationResult> {
+    return this.delegate.uninstallMcp(name, opts);
+  }
+
+  async listInstalledMcp(projectPath?: string): Promise<InstalledMcpEntry[]> {
+    return this.delegate.listInstalledMcp(projectPath);
+  }
+
+  async listInstalledPlugins(): Promise<InstalledPluginEntry[]> {
+    return [];
+  }
+
+  getSkillRoots(projectPath?: string): ResolvedSkillRoot[] {
+    const home = getHomeDir();
+    const roots: ResolvedSkillRoot[] = [
+      { kind: 'gemini', scope: 'user', path: path.join(home, '.gemini', 'skills') },
+    ];
+    if (projectPath) {
+      roots.push({
+        kind: 'gemini',
+        scope: 'project',
+        path: path.join(projectPath, '.gemini', 'skills'),
+      });
+    }
+    return roots;
+  }
+}

package/src/main/services/extensions/runtime/HarnessInstallAdapter.ts

@@ -0,0 +1,49 @@
+/**
+ * Harness install adapter interface.
+ *
+ * Each supported harness implements this interface to provide
+ * harness-specific installation commands and configuration paths.
+ */
+
+import type { CcAgentType } from '@shared/types/ccConnect';
+import type { McpHeaderDef, McpInstallSpec, OperationResult } from '@shared/types/extensions';
+
+import type { InstalledMcpEntry } from '@shared/types/extensions';
+import type { InstalledPluginEntry } from '@shared/types/extensions';
+
+export interface InstallOpts {
+  scope: 'user' | 'project' | 'local' | 'global';
+  projectPath?: string;
+}
+
+export interface ResolvedSkillRoot {
+  kind: string;
+  scope: 'user' | 'project';
+  path: string;
+}
+
+export interface HarnessInstallAdapter {
+  readonly harnessType: CcAgentType;
+  readonly supportsPlugins: boolean;
+  readonly supportsMcp: boolean;
+  readonly supportsSkills: boolean;
+
+  resolveBinary(): Promise<string | null>;
+
+  installPlugin(qualifiedName: string, opts: InstallOpts): Promise<OperationResult>;
+  uninstallPlugin(qualifiedName: string, opts: InstallOpts): Promise<OperationResult>;
+
+  installMcp(
+    name: string,
+    spec: McpInstallSpec,
+    envValues: Record<string, string>,
+    headers: McpHeaderDef[],
+    opts: InstallOpts
+  ): Promise<OperationResult>;
+  uninstallMcp(name: string, opts: InstallOpts): Promise<OperationResult>;
+
+  listInstalledMcp(projectPath?: string): Promise<InstalledMcpEntry[]>;
+  listInstalledPlugins(projectPath?: string): Promise<InstalledPluginEntry[]>;
+
+  getSkillRoots(projectPath?: string): ResolvedSkillRoot[];
+}

package/src/main/services/extensions/runtime/McpConfigStateReader.ts

@@ -0,0 +1,209 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+import { getHomeDir } from '@main/utils/pathDecoder';
+import { createLogger } from '@shared/utils/logger';
+
+import type { InstalledMcpEntry } from '@shared/types/extensions';
+
+const logger = createLogger('Extensions:McpConfigStateReader');
+
+export interface ConfiguredMcpEntry extends InstalledMcpEntry {
+  scope: 'local' | 'user' | 'project';
+  config: Record<string, unknown>;
+}
+
+export class McpConfigStateReader {
+  async readInstalled(projectPath?: string): Promise<InstalledMcpEntry[]> {
+    const entries: InstalledMcpEntry[] = [];
+    const claudeConfig = await this.readClaudeConfig();
+
+    entries.push(...this.readUserMcpServers(claudeConfig));
+
+    // Also read from ~/.claude/settings.json (newer Claude Code versions)
+    const settingsConfig = await this.readClaudeSettingsConfig();
+    entries.push(...this.readUserMcpServers(settingsConfig));
+
+    if (projectPath) {
+      entries.push(...this.readLocalMcpServers(claudeConfig, projectPath));
+      entries.push(...(await this.readProjectMcpServers(projectPath)));
+    }
+
+    // Deduplicate by name (settings.json takes precedence if both exist)
+    const seen = new Map<string, InstalledMcpEntry>();
+    for (const entry of entries) {
+      if (!seen.has(entry.name)) {
+        seen.set(entry.name, entry);
+      }
+    }
+
+    return [...seen.values()];
+  }
+
+  async readConfigured(projectPath?: string): Promise<ConfiguredMcpEntry[]> {
+    const entries: ConfiguredMcpEntry[] = [];
+    const claudeConfig = await this.readClaudeConfig();
+
+    entries.push(...this.readConfiguredMcpServersFromConfig(claudeConfig?.mcpServers, 'user'));
+
+    const settingsConfig = await this.readClaudeSettingsConfig();
+    entries.push(...this.readConfiguredMcpServersFromConfig(settingsConfig?.mcpServers, 'user'));
+
+    if (projectPath) {
+      entries.push(...this.readLocalConfiguredMcpServers(claudeConfig, projectPath));
+      entries.push(...(await this.readProjectConfiguredMcpServers(projectPath)));
+    }
+
+    // Deduplicate by name
+    const seen = new Map<string, ConfiguredMcpEntry>();
+    for (const entry of entries) {
+      if (!seen.has(entry.name)) {
+        seen.set(entry.name, entry);
+      }
+    }
+
+    return [...seen.values()];
+  }
+
+  private async readClaudeConfig(): Promise<Record<string, unknown> | null> {
+    const configPath = path.join(getHomeDir(), '.claude.json');
+    try {
+      const raw = await fs.readFile(configPath, 'utf-8');
+      return JSON.parse(raw) as Record<string, unknown>;
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        return null;
+      }
+      logger.error(`Failed to read MCP servers from ${configPath}:`, err);
+      return null;
+    }
+  }
+
+  /**
+   * Read ~/.claude/settings.json — newer Claude Code versions store MCP configs here.
+   */
+  private async readClaudeSettingsConfig(): Promise<Record<string, unknown> | null> {
+    const configPath = path.join(getHomeDir(), '.claude', 'settings.json');
+    try {
+      const raw = await fs.readFile(configPath, 'utf-8');
+      return JSON.parse(raw) as Record<string, unknown>;
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        return null;
+      }
+      logger.error(`Failed to read MCP servers from ${configPath}:`, err);
+      return null;
+    }
+  }
+
+  private readUserMcpServers(config: Record<string, unknown> | null): InstalledMcpEntry[] {
+    return this.readMcpServersFromConfig(config?.mcpServers, 'user');
+  }
+
+  private readLocalMcpServers(
+    config: Record<string, unknown> | null,
+    projectPath: string
+  ): InstalledMcpEntry[] {
+    return this.readLocalConfiguredMcpServers(config, projectPath).map(
+      ({ config: _config, ...entry }) => entry
+    );
+  }
+
+  private readLocalConfiguredMcpServers(
+    config: Record<string, unknown> | null,
+    projectPath: string
+  ): ConfiguredMcpEntry[] {
+    const projects =
+      config && typeof config.projects === 'object' && config.projects
+        ? (config.projects as Record<string, unknown>)
+        : null;
+    const projectConfig =
+      projects && typeof projects[projectPath] === 'object' && projects[projectPath]
+        ? (projects[projectPath] as Record<string, unknown>)
+        : null;
+    return this.readConfiguredMcpServersFromConfig(projectConfig?.mcpServers, 'local');
+  }
+
+  private async readProjectMcpServers(projectPath: string): Promise<InstalledMcpEntry[]> {
+    const configPath = path.join(projectPath, '.mcp.json');
+    return this.readMcpServersFromFile(configPath, 'project');
+  }
+
+  private async readProjectConfiguredMcpServers(
+    projectPath: string
+  ): Promise<ConfiguredMcpEntry[]> {
+    const configPath = path.join(projectPath, '.mcp.json');
+    return this.readConfiguredMcpServersFromFile(configPath, 'project');
+  }
+
+  private readMcpServersFromConfig(
+    value: unknown,
+    scope: 'user' | 'project' | 'local'
+  ): InstalledMcpEntry[] {
+    const mcpServers =
+      value && typeof value === 'object'
+        ? (value as Record<string, { command?: string; url?: string }>)
+        : null;
+    if (!mcpServers) {
+      return [];
+    }
+
+    return Object.entries(mcpServers).map(([name, config]): InstalledMcpEntry => {
+      let transport: string | undefined;
+      if (config.command) transport = 'stdio';
+      else if (config.url) transport = 'http';
+
+      return { name, scope, transport };
+    });
+  }
+
+  private readConfiguredMcpServersFromConfig(
+    value: unknown,
+    scope: 'user' | 'project' | 'local'
+  ): ConfiguredMcpEntry[] {
+    const mcpServers =
+      value && typeof value === 'object' ? (value as Record<string, unknown>) : null;
+    if (!mcpServers) {
+      return [];
+    }
+
+    return Object.entries(mcpServers)
+      .filter((entry): entry is [string, Record<string, unknown>] => {
+        const [, config] = entry;
+        return Boolean(config && typeof config === 'object' && !Array.isArray(config));
+      })
+      .map(([name, config]): ConfiguredMcpEntry => {
+        let transport: string | undefined;
+        if (typeof config.command === 'string') transport = 'stdio';
+        else if (typeof config.url === 'string') transport = 'http';
+
+        return { name, scope, transport, config: { ...config } };
+      });
+  }
+
+  private async readMcpServersFromFile(
+    filePath: string,
+    scope: 'user' | 'project'
+  ): Promise<InstalledMcpEntry[]> {
+    return (await this.readConfiguredMcpServersFromFile(filePath, scope)).map(
+      ({ config: _config, ...entry }) => entry
+    );
+  }
+
+  private async readConfiguredMcpServersFromFile(
+    filePath: string,
+    scope: 'user' | 'project'
+  ): Promise<ConfiguredMcpEntry[]> {
+    try {
+      const raw = await fs.readFile(filePath, 'utf-8');
+      const json = JSON.parse(raw) as Record<string, unknown>;
+      return this.readConfiguredMcpServersFromConfig(json.mcpServers, scope);
+    } catch (err) {
+      if ((err as NodeJS.ErrnoException).code === 'ENOENT') {
+        return [];
+      }
+      logger.error(`Failed to read MCP servers from ${filePath}:`, err);
+      return [];
+    }
+  }
+}

package/src/main/services/extensions/runtime/OpenCodeAdapter.ts

@@ -0,0 +1,91 @@
+/**
+ * OpenCode harness adapter — uses `opencode` CLI for MCP and skills.
+ */
+
+import { getHomeDir } from '@main/utils/pathDecoder';
+import type { CcAgentType } from '@shared/types/ccConnect';
+import path from 'node:path';
+
+import { ClaudeCodeAdapter } from './ClaudeCodeAdapter';
+
+import type {
+  HarnessInstallAdapter,
+  InstallOpts,
+  ResolvedSkillRoot,
+} from './HarnessInstallAdapter';
+import type {
+  InstalledMcpEntry,
+  InstalledPluginEntry,
+  McpHeaderDef,
+  McpInstallSpec,
+  OperationResult,
+} from '@shared/types/extensions';
+
+function resolveBinaryFromPath(binaryName: string): Promise<string | null> {
+  return new Promise((resolve) => {
+    import('node:child_process')
+      .then(({ execFile }) => {
+        execFile('which', [binaryName], { timeout: 5_000 }, (err, stdout) => {
+          resolve(err || !stdout?.trim() ? null : stdout.trim());
+        });
+      })
+      .catch(() => resolve(null));
+  });
+}
+
+export class OpenCodeAdapter implements HarnessInstallAdapter {
+  readonly harnessType: CcAgentType = 'opencode';
+  readonly supportsPlugins = false;
+  readonly supportsMcp = true;
+  readonly supportsSkills = true;
+
+  private readonly delegate = new ClaudeCodeAdapter();
+
+  async resolveBinary(): Promise<string | null> {
+    return resolveBinaryFromPath('opencode');
+  }
+
+  async installPlugin(): Promise<OperationResult> {
+    return { state: 'error', error: 'OpenCode does not support Claude plugins' };
+  }
+  async uninstallPlugin(): Promise<OperationResult> {
+    return { state: 'error', error: 'OpenCode does not support Claude plugins' };
+  }
+
+  async installMcp(
+    name: string,
+    spec: McpInstallSpec,
+    envValues: Record<string, string>,
+    headers: McpHeaderDef[],
+    opts: InstallOpts
+  ): Promise<OperationResult> {
+    return this.delegate.installMcp(name, spec, envValues, headers, opts);
+  }
+
+  async uninstallMcp(name: string, opts: InstallOpts): Promise<OperationResult> {
+    return this.delegate.uninstallMcp(name, opts);
+  }
+
+  async listInstalledMcp(projectPath?: string): Promise<InstalledMcpEntry[]> {
+    return this.delegate.listInstalledMcp(projectPath);
+  }
+
+  async listInstalledPlugins(): Promise<InstalledPluginEntry[]> {
+    return [];
+  }
+
+  getSkillRoots(projectPath?: string): ResolvedSkillRoot[] {
+    const home = getHomeDir();
+    const roots: ResolvedSkillRoot[] = [
+      { kind: 'opencode', scope: 'user', path: path.join(home, '.opencode', 'skills') },
+    ];
+    if (projectPath) {
+      roots.push({
+        kind: 'opencode',
+        scope: 'project',
+        path: path.join(projectPath, '.opencode', 'skills'),
+      });
+    }
+    return roots;
+  }
+}

package/src/main/services/extensions/runtime/adapterRegistry.ts

@@ -0,0 +1,54 @@
+/**
+ * Adapter registry — maps harness types to their install adapters.
+ */
+
+import type { CcAgentType } from '@shared/types/ccConnect';
+
+import type { HarnessInstallAdapter } from './HarnessInstallAdapter';
+import { ClaudeCodeAdapter } from './ClaudeCodeAdapter';
+import { CodexAdapter } from './CodexAdapter';
+import { CursorAdapter } from './CursorAdapter';
+import { GeminiAdapter } from './GeminiAdapter';
+import { OpenCodeAdapter } from './OpenCodeAdapter';
+
+const adapters = new Map<CcAgentType, HarnessInstallAdapter>();
+
+function registerDefaults(): void {
+  if (adapters.size > 0) return;
+  const instances: HarnessInstallAdapter[] = [
+    new ClaudeCodeAdapter(),
+    new CodexAdapter(),
+    new GeminiAdapter(),
+    new OpenCodeAdapter(),
+    new CursorAdapter(),
+  ];
+  for (const adapter of instances) {
+    adapters.set(adapter.harnessType, adapter);
+  }
+}
+
+export function getAdapter(harnessType: CcAgentType): HarnessInstallAdapter | null {
+  registerDefaults();
+  return adapters.get(harnessType) ?? null;
+}
+
+export function getAllAdapters(): HarnessInstallAdapter[] {
+  registerDefaults();
+  return [...adapters.values()];
+}
+
+export function getAdaptersForCapability(
+  capability: 'plugins' | 'mcp' | 'skills'
+): HarnessInstallAdapter[] {
+  registerDefaults();
+  return [...adapters.values()].filter((a) => {
+    switch (capability) {
+      case 'plugins':
+        return a.supportsPlugins;
+      case 'mcp':
+        return a.supportsMcp;
+      case 'skills':
+        return a.supportsSkills;
+    }
+  });
+}