@yancyyu/openhermit 1.6.29 → 1.6.31

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

@@ -0,0 +1,199 @@
+/**
+ * Claude Code harness adapter — uses `claude` CLI for plugin/MCP/skills.
+ */
+
+import { ClaudeBinaryResolver } from '@main/services/team/ClaudeBinaryResolver';
+import { getHomeDir } from '@main/utils/pathDecoder';
+import { execCli } from '@main/utils/childProcess';
+import { CLI_NOT_FOUND_MESSAGE } from '@shared/constants/cli';
+import type { CcAgentType } from '@shared/types/ccConnect';
+import { createLogger } from '@shared/utils/logger';
+import path from 'node:path';
+
+import { McpConfigStateReader } from './McpConfigStateReader';
+
+import type {
+  HarnessInstallAdapter,
+  InstallOpts,
+  ResolvedSkillRoot,
+} from './HarnessInstallAdapter';
+import type {
+  InstalledMcpEntry,
+  InstalledPluginEntry,
+  McpHeaderDef,
+  McpInstallSpec,
+  OperationResult,
+} from '@shared/types/extensions';
+
+const logger = createLogger('Extensions:CCAdapter');
+
+const QUALIFIED_NAME_RE = /^[\w.-]+@[\w.-]+$/;
+const VALID_SCOPES = new Set(['local', 'user', 'project', 'global']);
+const SERVER_NAME_RE = /^[\w.-]{1,100}$/;
+const ENV_KEY_RE = /^[A-Z_][A-Z0-9_]{0,100}$/i;
+const HEADER_KEY_RE = /^[A-Za-z][\w-]{0,100}$/;
+const PLUGIN_TIMEOUT_MS = 120_000;
+const MCP_TIMEOUT_MS = 30_000;
+
+function scopeRequiresProjectPath(scope?: string): boolean {
+  return scope === 'project' || scope === 'local';
+}
+
+function maskSecrets(
+  message: string,
+  envValues: Record<string, string>,
+  headerValues: string[]
+): string {
+  let result = message;
+  const secrets = [
+    ...Object.values(envValues).filter((v) => v.length > 3),
+    ...headerValues.filter((v) => v.length > 3),
+  ];
+  for (const secret of secrets) {
+    result = result.replaceAll(secret, '[REDACTED]');
+  }
+  return result;
+}
+
+export class ClaudeCodeAdapter implements HarnessInstallAdapter {
+  readonly harnessType: CcAgentType = 'claudecode';
+  readonly supportsPlugins = true;
+  readonly supportsMcp = true;
+  readonly supportsSkills = true;
+
+  private readonly configReader = new McpConfigStateReader();
+
+  async resolveBinary(): Promise<string | null> {
+    return ClaudeBinaryResolver.resolve();
+  }
+
+  async installPlugin(qualifiedName: string, opts: InstallOpts): Promise<OperationResult> {
+    if (!QUALIFIED_NAME_RE.test(qualifiedName)) {
+      return { state: 'error', error: `Invalid plugin identifier: ${qualifiedName}` };
+    }
+    if (opts.scope && !VALID_SCOPES.has(opts.scope)) {
+      return { state: 'error', error: `Invalid scope: "${opts.scope}"` };
+    }
+    if (scopeRequiresProjectPath(opts.scope) && !opts.projectPath) {
+      return { state: 'error', error: 'projectPath is required for project-scoped installs' };
+    }
+
+    const args = ['plugin', 'install'];
+    if (opts.scope && opts.scope !== 'user') args.push('-s', opts.scope);
+    args.push(qualifiedName);
+
+    return this.runCli(args, { timeout: PLUGIN_TIMEOUT_MS, cwd: opts.projectPath });
+  }
+
+  async uninstallPlugin(qualifiedName: string, opts: InstallOpts): Promise<OperationResult> {
+    if (!QUALIFIED_NAME_RE.test(qualifiedName)) {
+      return { state: 'error', error: `Invalid plugin identifier: ${qualifiedName}` };
+    }
+
+    const args = ['plugin', 'uninstall'];
+    if (opts.scope && opts.scope !== 'user') args.push('-s', opts.scope);
+    args.push(qualifiedName);
+
+    return this.runCli(args, { timeout: 30_000, cwd: opts.projectPath });
+  }
+
+  async installMcp(
+    name: string,
+    spec: McpInstallSpec,
+    envValues: Record<string, string>,
+    headers: McpHeaderDef[],
+    opts: InstallOpts
+  ): Promise<OperationResult> {
+    if (!SERVER_NAME_RE.test(name)) {
+      return { state: 'error', error: `Invalid server name: "${name}"` };
+    }
+
+    const args: string[] = ['mcp', 'add'];
+    if (opts.scope && opts.scope !== 'local') args.push('-s', opts.scope);
+
+    if (spec.type === 'stdio') {
+      for (const [key, value] of Object.entries(envValues)) {
+        if (key && value && ENV_KEY_RE.test(key)) args.push('-e', `${key}=${value}`);
+      }
+      args.push(name, '--', 'npx', '-y');
+      args.push(spec.npmVersion ? `${spec.npmPackage}@${spec.npmVersion}` : spec.npmPackage);
+    } else if (spec.type === 'http') {
+      args.push('-t', spec.transportType === 'sse' ? 'sse' : 'http');
+      // Positional args must come before variadic flags (-H, -e)
+      // to prevent the CLI parser from consuming them as flag values
+      args.push(name, spec.url);
+      for (const header of headers) {
+        if (header.key && header.value && HEADER_KEY_RE.test(header.key))
+          args.push('-H', `${header.key}: ${header.value}`);
+      }
+      for (const [key, value] of Object.entries(envValues)) {
+        if (key && value && ENV_KEY_RE.test(key)) args.push('-e', `${key}=${value}`);
+      }
+    } else {
+      return { state: 'error', error: `Unsupported install spec type` };
+    }
+
+    try {
+      return await this.runCli(args, { timeout: MCP_TIMEOUT_MS, cwd: opts.projectPath });
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      const safe = maskSecrets(
+        message,
+        envValues,
+        headers.map((h) => h.value)
+      );
+      return { state: 'error', error: safe };
+    }
+  }
+
+  async uninstallMcp(name: string, opts: InstallOpts): Promise<OperationResult> {
+    const args = ['mcp', 'remove'];
+    if (opts.scope && opts.scope !== 'local') args.push('-s', opts.scope);
+    args.push(name);
+    return this.runCli(args, { timeout: MCP_TIMEOUT_MS, cwd: opts.projectPath });
+  }
+
+  async listInstalledMcp(projectPath?: string): Promise<InstalledMcpEntry[]> {
+    return this.configReader.readInstalled(projectPath);
+  }
+
+  async listInstalledPlugins(_projectPath?: string): Promise<InstalledPluginEntry[]> {
+    // Plugin listing would read from ~/.claude/plugins/installed_plugins.json
+    // Stub for now — will be implemented in Phase 3
+    return [];
+  }
+
+  getSkillRoots(projectPath?: string): ResolvedSkillRoot[] {
+    const home = getHomeDir();
+    const roots: ResolvedSkillRoot[] = [
+      { kind: 'claude', scope: 'user', path: path.join(home, '.claude', 'commands') },
+    ];
+    if (projectPath) {
+      roots.push({
+        kind: 'claude',
+        scope: 'project',
+        path: path.join(projectPath, '.claude', 'commands'),
+      });
+    }
+    return roots;
+  }
+
+  private async runCli(
+    args: string[],
+    opts: { timeout: number; cwd?: string }
+  ): Promise<OperationResult> {
+    const binary = await this.resolveBinary();
+    if (!binary) {
+      return { state: 'error', error: CLI_NOT_FOUND_MESSAGE };
+    }
+
+    try {
+      await execCli(binary, args, { timeout: opts.timeout, cwd: opts.cwd });
+      return { state: 'success' };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      logger.error(`CLI command failed: ${message}`);
+      return { state: 'error', error: message };
+    }
+  }
+}

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

@@ -0,0 +1,100 @@
+/**
+ * Codex harness adapter — uses `codex` CLI for MCP and skills.
+ * Shares CLI pattern with ClaudeCodeAdapter but uses `codex` binary.
+ */
+
+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));
+  });
+}
+
+/**
+ * Codex adapter — delegates to a ClaudeCodeAdapter instance but overrides
+ * binary resolution and skill roots. CLI args pattern is the same.
+ */
+export class CodexAdapter implements HarnessInstallAdapter {
+  readonly harnessType: CcAgentType = 'codex';
+  readonly supportsPlugins = false;
+  readonly supportsMcp = true;
+  readonly supportsSkills = true;
+
+  private readonly delegate = new ClaudeCodeAdapter();
+
+  async resolveBinary(): Promise<string | null> {
+    const codex = await resolveBinaryFromPath('codex');
+    if (codex) return codex;
+    // Fallback: try claude binary (codex may be aliased)
+    return this.delegate.resolveBinary();
+  }
+
+  async installPlugin(): Promise<OperationResult> {
+    return { state: 'error', error: 'Codex does not support Claude plugins' };
+  }
+
+  async uninstallPlugin(): Promise<OperationResult> {
+    return { state: 'error', error: 'Codex 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: 'codex', scope: 'user', path: path.join(home, '.codex', 'skills') },
+    ];
+    if (projectPath) {
+      roots.push({
+        kind: 'codex',
+        scope: 'project',
+        path: path.join(projectPath, '.codex', 'skills'),
+      });
+    }
+    return roots;
+  }
+}

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

@@ -0,0 +1,154 @@
+/**
+ * Cursor harness adapter — writes config files directly (no CLI for MCP).
+ */
+
+import * as fs from 'node:fs/promises';
+import { getHomeDir } from '@main/utils/pathDecoder';
+import { createLogger } from '@shared/utils/logger';
+import path from 'node:path';
+
+import type {
+  HarnessInstallAdapter,
+  InstallOpts,
+  ResolvedSkillRoot,
+} from './HarnessInstallAdapter';
+import type {
+  InstalledMcpEntry,
+  InstalledPluginEntry,
+  McpHeaderDef,
+  McpInstallSpec,
+  OperationResult,
+} from '@shared/types/extensions';
+
+const logger = createLogger('Extensions:CursorAdapter');
+
+export class CursorAdapter implements HarnessInstallAdapter {
+  readonly harnessType = 'cursor' as const;
+  readonly supportsPlugins = false;
+  readonly supportsMcp = true;
+  readonly supportsSkills = true;
+
+  async resolveBinary(): Promise<string | null> {
+    // Cursor doesn't have a CLI for MCP management
+    return null;
+  }
+
+  async installMcp(
+    name: string,
+    spec: McpInstallSpec,
+    envValues: Record<string, string>,
+    _headers: McpHeaderDef[],
+    opts: InstallOpts
+  ): Promise<OperationResult> {
+    if (!opts.projectPath) {
+      return { state: 'error', error: 'Cursor MCP requires a project path (.cursor/mcp.json)' };
+    }
+
+    const mcpPath = path.join(opts.projectPath, '.cursor', 'mcp.json');
+    let config: Record<string, unknown> = {};
+
+    try {
+      const raw = await fs.readFile(mcpPath, 'utf-8');
+      config = JSON.parse(raw) as Record<string, unknown>;
+    } catch {
+      // file doesn't exist yet
+    }
+
+    const mcpServers = (config.mcpServers as Record<string, unknown>) ?? {};
+
+    if (spec.type === 'stdio') {
+      mcpServers[name] = {
+        command: 'npx',
+        args: ['-y', spec.npmVersion ? `${spec.npmPackage}@${spec.npmVersion}` : spec.npmPackage],
+        env: envValues,
+      };
+    } else if (spec.type === 'http') {
+      mcpServers[name] = {
+        url: spec.url,
+        ...(spec.transportType === 'sse' && { type: 'sse' }),
+      };
+    }
+
+    config.mcpServers = mcpServers;
+
+    try {
+      await fs.mkdir(path.dirname(mcpPath), { recursive: true });
+      await fs.writeFile(mcpPath, JSON.stringify(config, null, 2));
+      return { state: 'success' };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { state: 'error', error: `Failed to write .cursor/mcp.json: ${message}` };
+    }
+  }
+
+  async uninstallMcp(name: string, opts: InstallOpts): Promise<OperationResult> {
+    if (!opts.projectPath) {
+      return { state: 'error', error: 'Cursor MCP requires a project path' };
+    }
+
+    const mcpPath = path.join(opts.projectPath, '.cursor', 'mcp.json');
+
+    try {
+      const raw = await fs.readFile(mcpPath, 'utf-8');
+      const config = JSON.parse(raw) as Record<string, unknown>;
+      const mcpServers = config.mcpServers as Record<string, unknown> | undefined;
+      if (mcpServers && name in mcpServers) {
+        delete mcpServers[name];
+        await fs.writeFile(mcpPath, JSON.stringify(config, null, 2));
+      }
+      return { state: 'success' };
+    } catch (err) {
+      const message = err instanceof Error ? err.message : String(err);
+      return { state: 'error', error: `Failed to update .cursor/mcp.json: ${message}` };
+    }
+  }
+
+  async installPlugin(): Promise<OperationResult> {
+    return { state: 'error', error: 'Cursor does not support Claude plugins' };
+  }
+
+  async uninstallPlugin(): Promise<OperationResult> {
+    return { state: 'error', error: 'Cursor does not support Claude plugins' };
+  }
+
+  async listInstalledMcp(projectPath?: string): Promise<InstalledMcpEntry[]> {
+    if (!projectPath) return [];
+    const mcpPath = path.join(projectPath, '.cursor', 'mcp.json');
+
+    try {
+      const raw = await fs.readFile(mcpPath, 'utf-8');
+      const config = JSON.parse(raw) as Record<string, unknown>;
+      const mcpServers = config.mcpServers as
+        | Record<string, { command?: string; url?: string }>
+        | undefined;
+      if (!mcpServers) return [];
+
+      return Object.entries(mcpServers).map(([name, server]) => ({
+        name,
+        scope: 'project' as const,
+        transport: server.command ? 'stdio' : server.url ? 'http' : undefined,
+      }));
+    } catch {
+      return [];
+    }
+  }
+
+  async listInstalledPlugins(): Promise<InstalledPluginEntry[]> {
+    return [];
+  }
+
+  getSkillRoots(projectPath?: string): ResolvedSkillRoot[] {
+    const home = getHomeDir();
+    const roots: ResolvedSkillRoot[] = [
+      { kind: 'cursor', scope: 'user', path: path.join(home, '.cursor', 'skills') },
+    ];
+    if (projectPath) {
+      roots.push({
+        kind: 'cursor',
+        scope: 'project',
+        path: path.join(projectPath, '.cursor', 'skills'),
+      });
+    }
+    return roots;
+  }
+}

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

@@ -0,0 +1,172 @@
+import { buildProviderAwareCliEnv } from '@main/services/runtime/providerAwareCliEnv';
+import { ClaudeBinaryResolver } from '@main/services/team/ClaudeBinaryResolver';
+import { getConfiguredCliFlavor } from '@main/services/team/cliFlavor';
+import { execCli } from '@main/utils/childProcess';
+import { CLI_NOT_FOUND_MESSAGE } from '@shared/constants/cli';
+
+import { McpConfigStateReader } from './McpConfigStateReader';
+import { parseMcpDiagnosticsJsonOutput, parseMcpDiagnosticsOutput } from './mcpDiagnosticsParser';
+import { parseInstalledMcpJsonOutput } from './mcpRuntimeJson';
+
+import type { CliFlavor } from '@shared/types';
+import type { InstalledMcpEntry, McpServerDiagnostic } from '@shared/types/extensions';
+
+const MCP_LIST_TIMEOUT_MS = 15_000;
+const MCP_DIAGNOSE_TIMEOUT_MS = 60_000;
+
+async function buildManagementCliEnvForBinary(binaryPath: string): Promise<NodeJS.ProcessEnv> {
+  const { env } = await buildProviderAwareCliEnv({
+    binaryPath,
+    connectionMode: 'augment',
+    allowStoredApiKeyDecryption: false,
+  });
+  return env;
+}
+export interface ExtensionsRuntimeAdapter {
+  readonly flavor: CliFlavor;
+  buildManagementCliEnv(binaryPath: string): Promise<NodeJS.ProcessEnv>;
+  getInstalledMcp(projectPath?: string): Promise<InstalledMcpEntry[]>;
+  diagnoseMcp(projectPath?: string): Promise<McpServerDiagnostic[]>;
+}
+
+export class ClaudeExtensionsAdapter implements ExtensionsRuntimeAdapter {
+  readonly flavor = 'claude' as const;
+
+  constructor(private readonly stateReader = new McpConfigStateReader()) {}
+
+  async buildManagementCliEnv(binaryPath: string): Promise<NodeJS.ProcessEnv> {
+    return buildManagementCliEnvForBinary(binaryPath);
+  }
+
+  async getInstalledMcp(projectPath?: string): Promise<InstalledMcpEntry[]> {
+    return this.stateReader.readInstalled(projectPath);
+  }
+
+  async diagnoseMcp(projectPath?: string): Promise<McpServerDiagnostic[]> {
+    const binaryPath = await ClaudeBinaryResolver.resolve();
+    if (!binaryPath) {
+      throw new Error(CLI_NOT_FOUND_MESSAGE);
+    }
+
+    const env = await this.buildManagementCliEnv(binaryPath);
+    const { stdout, stderr } = await execCli(binaryPath, ['mcp', 'list'], {
+      timeout: MCP_DIAGNOSE_TIMEOUT_MS,
+      cwd: projectPath,
+      env,
+    });
+
+    return parseMcpDiagnosticsOutput([stdout, stderr].filter(Boolean).join('\n'));
+  }
+}
+
+export class MultimodelExtensionsAdapter implements ExtensionsRuntimeAdapter {
+  readonly flavor = 'agent_teams_orchestrator' as const;
+
+  constructor(private readonly stateReader = new McpConfigStateReader()) {}
+
+  async buildManagementCliEnv(binaryPath: string): Promise<NodeJS.ProcessEnv> {
+    return buildManagementCliEnvForBinary(binaryPath);
+  }
+
+  async getInstalledMcp(projectPath?: string): Promise<InstalledMcpEntry[]> {
+    const binaryPath = await ClaudeBinaryResolver.resolve();
+    if (!binaryPath) {
+      return this.stateReader.readInstalled(projectPath);
+    }
+
+    const env = await this.buildManagementCliEnv(binaryPath);
+    try {
+      const { stdout } = await execCli(binaryPath, ['mcp', 'list', '--json'], {
+        timeout: MCP_LIST_TIMEOUT_MS,
+        cwd: projectPath,
+        env,
+      });
+
+      return parseInstalledMcpJsonOutput(stdout);
+    } catch (error) {
+      if (!isUnsupportedMcpJsonContractError(error)) {
+        throw error;
+      }
+
+      return this.stateReader.readInstalled(projectPath);
+    }
+  }
+
+  async diagnoseMcp(projectPath?: string): Promise<McpServerDiagnostic[]> {
+    const binaryPath = await ClaudeBinaryResolver.resolve();
+    if (!binaryPath) {
+      return [];
+    }
+
+    const env = await this.buildManagementCliEnv(binaryPath);
+    try {
+      const { stdout } = await execCli(binaryPath, ['mcp', 'diagnose', '--json'], {
+        timeout: MCP_DIAGNOSE_TIMEOUT_MS,
+        cwd: projectPath,
+        env,
+      });
+
+      return parseMcpDiagnosticsJsonOutput(stdout);
+    } catch (error) {
+      if (!isUnsupportedMcpJsonContractError(error)) {
+        throw error;
+      }
+
+      const { stdout, stderr } = await execCli(binaryPath, ['mcp', 'list'], {
+        timeout: MCP_DIAGNOSE_TIMEOUT_MS,
+        cwd: projectPath,
+        env,
+      });
+
+      return parseMcpDiagnosticsOutput([stdout, stderr].filter(Boolean).join('\n'));
+    }
+  }
+}
+
+function isUnsupportedMcpJsonContractError(error: unknown): boolean {
+  const message = error instanceof Error ? error.message : String(error);
+  const normalized = message.toLowerCase();
+
+  return (
+    normalized.includes("unknown command 'diagnose'") ||
+    normalized.includes('unknown command "diagnose"') ||
+    normalized.includes('unknown option') ||
+    normalized.includes('unknown argument') ||
+    normalized.includes('unexpected argument') ||
+    normalized.includes('unrecognized option')
+  );
+}
+
+class RuntimeSwitchingExtensionsAdapter implements ExtensionsRuntimeAdapter {
+  constructor(
+    private readonly claudeAdapter: ClaudeExtensionsAdapter,
+    private readonly multimodelAdapter: MultimodelExtensionsAdapter
+  ) {}
+
+  private getActiveAdapter(): ExtensionsRuntimeAdapter {
+    return getConfiguredCliFlavor() === 'claude' ? this.claudeAdapter : this.multimodelAdapter;
+  }
+
+  get flavor(): CliFlavor {
+    return this.getActiveAdapter().flavor;
+  }
+
+  buildManagementCliEnv(binaryPath: string): Promise<NodeJS.ProcessEnv> {
+    return this.getActiveAdapter().buildManagementCliEnv(binaryPath);
+  }
+
+  getInstalledMcp(projectPath?: string): Promise<InstalledMcpEntry[]> {
+    return this.getActiveAdapter().getInstalledMcp(projectPath);
+  }
+
+  diagnoseMcp(projectPath?: string): Promise<McpServerDiagnostic[]> {
+    return this.getActiveAdapter().diagnoseMcp(projectPath);
+  }
+}
+
+export function createExtensionsRuntimeAdapter(): ExtensionsRuntimeAdapter {
+  return new RuntimeSwitchingExtensionsAdapter(
+    new ClaudeExtensionsAdapter(),
+    new MultimodelExtensionsAdapter()
+  );
+}