@yancyyu/openhermit 1.6.29 → 1.6.30

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

@@ -0,0 +1,214 @@
+import { isInstalledMcpScope } from '@shared/utils/mcpScopes';
+
+import type { McpServerDiagnostic, McpServerHealthStatus } from '@shared/types/extensions';
+
+interface McpDiagnoseJsonEntry {
+  name?: string;
+  target?: string;
+  scope?: 'local' | 'user' | 'project' | 'global' | 'dynamic' | 'managed';
+  transport?: string;
+  status?: 'connected' | 'needs-authentication' | 'failed' | 'timeout';
+  statusLabel?: string;
+}
+
+interface McpDiagnoseJsonPayload {
+  checkedAt?: string;
+  diagnostics?: McpDiagnoseJsonEntry[];
+}
+
+const EMBEDDED_HTTP_URL_PATTERN = /https?:\/\/[^\s"'`]+/gi;
+const SENSITIVE_FLAG_VALUE_PATTERN = /(--[a-z0-9_-]+)(?:=([^\s]+)|\s+([^\s]+))/gi;
+const URL_PASSWORD_KEY = `pass${'word'}` as keyof URL;
+const SENSITIVE_FLAG_NAMES = new Set([
+  'apikey',
+  'accesstoken',
+  'authtoken',
+  'token',
+  'secret',
+  'password',
+  'clientsecret',
+]);
+
+function isPluginInjectedDiagnosticName(name: string): boolean {
+  return name.startsWith('plugin:');
+}
+
+function isExtensionsManagedDiagnosticEntry(entry: {
+  name: string;
+  scope?: 'local' | 'user' | 'project' | 'global' | 'dynamic' | 'managed';
+}): boolean {
+  if (isPluginInjectedDiagnosticName(entry.name)) {
+    return false;
+  }
+
+  return entry.scope === undefined || isInstalledMcpScope(entry.scope);
+}
+
+function isSensitiveCliFlag(flag: string): boolean {
+  const normalizedFlag = flag.toLowerCase().replace(/^--/, '').replace(/[-_]/g, '');
+  return SENSITIVE_FLAG_NAMES.has(normalizedFlag);
+}
+function extractJsonObject<T>(raw: string): T {
+  const trimmed = raw.trim();
+  try {
+    return JSON.parse(trimmed) as T;
+  } catch {
+    const start = trimmed.indexOf('{');
+    const end = trimmed.lastIndexOf('}');
+    if (start >= 0 && end > start) {
+      return JSON.parse(trimmed.slice(start, end + 1)) as T;
+    }
+    throw new Error('No JSON object found in CLI output');
+  }
+}
+
+function parseStatusChunk(statusChunk: string): {
+  status: McpServerHealthStatus;
+  statusLabel: string;
+} {
+  const symbol = statusChunk[0];
+  const label = statusChunk.slice(1).trim() || 'Unknown';
+
+  switch (symbol) {
+    case '✓':
+      return { status: 'connected', statusLabel: label };
+    case '!':
+      return { status: 'needs-authentication', statusLabel: label };
+    case '✗':
+      return { status: 'failed', statusLabel: label };
+    default:
+      return { status: 'unknown', statusLabel: statusChunk };
+  }
+}
+
+function redactHttpUrl(urlString: string): string {
+  try {
+    const parsed = new URL(urlString);
+    if (parsed.protocol !== 'http:' && parsed.protocol !== 'https:') {
+      return urlString;
+    }
+
+    const passwordField = parsed[URL_PASSWORD_KEY];
+    const hasUsername = parsed.username.length > 0;
+    const hasPassword = Boolean(passwordField);
+
+    if (!hasUsername && !hasPassword && !parsed.search && !parsed.hash) {
+      return urlString;
+    }
+
+    const redactedSearchParams = new URLSearchParams(parsed.search);
+    for (const key of new Set(redactedSearchParams.keys())) {
+      redactedSearchParams.set(key, 'REDACTED');
+    }
+
+    const authPrefix =
+      hasUsername || hasPassword
+        ? `${hasUsername ? '***' : ''}${hasPassword ? `${hasUsername ? ':' : ''}***` : ''}@`
+        : '';
+    const searchSuffix = redactedSearchParams.size > 0 ? `?${redactedSearchParams.toString()}` : '';
+    const hashSuffix = parsed.hash ? '#REDACTED' : '';
+
+    return `${parsed.protocol}//${authPrefix}${parsed.host}${parsed.pathname}${searchSuffix}${hashSuffix}`;
+  } catch {
+    return urlString;
+  }
+}
+
+function redactDiagnosticTarget(target: string): string {
+  return target
+    .replace(EMBEDDED_HTTP_URL_PATTERN, (match) => redactHttpUrl(match))
+    .replace(
+      SENSITIVE_FLAG_VALUE_PATTERN,
+      (match, flag: string, inlineValue?: string, separatedValue?: string) => {
+        if (!isSensitiveCliFlag(flag)) {
+          return match;
+        }
+
+        return inlineValue || separatedValue ? `${flag}=REDACTED` : `${flag} REDACTED`;
+      }
+    );
+}
+
+function parseDiagnosticLine(line: string, checkedAt: number): McpServerDiagnostic | null {
+  const statusSeparatorIdx = line.lastIndexOf(' - ');
+  if (statusSeparatorIdx === -1) {
+    return null;
+  }
+
+  const descriptor = line.slice(0, statusSeparatorIdx).trim();
+  const statusChunk = line.slice(statusSeparatorIdx + 3).trim();
+
+  const nameSeparatorIdx = descriptor.indexOf(': ');
+  if (nameSeparatorIdx === -1) {
+    return null;
+  }
+
+  const name = descriptor.slice(0, nameSeparatorIdx).trim();
+  const target = redactDiagnosticTarget(descriptor.slice(nameSeparatorIdx + 2).trim());
+  if (!name || !target) {
+    return null;
+  }
+
+  const { status, statusLabel } = parseStatusChunk(statusChunk);
+
+  return {
+    name,
+    target,
+    status,
+    statusLabel,
+    rawLine: line,
+    checkedAt,
+  };
+}
+
+export function parseMcpDiagnosticsOutput(output: string): McpServerDiagnostic[] {
+  const checkedAt = Date.now();
+
+  return output
+    .split(/\r?\n/)
+    .map((line) => line.trim())
+    .filter((line) => line.length > 0 && !line.startsWith('Checking MCP server health'))
+    .map((line) => parseDiagnosticLine(line, checkedAt))
+    .filter((entry): entry is McpServerDiagnostic => entry !== null)
+    .filter((entry) => isExtensionsManagedDiagnosticEntry(entry));
+}
+
+export function parseMcpDiagnosticsJsonOutput(output: string): McpServerDiagnostic[] {
+  const parsed = extractJsonObject<McpDiagnoseJsonPayload>(output);
+  const checkedAtValue = parsed.checkedAt ? Date.parse(parsed.checkedAt) : Number.NaN;
+  const checkedAt = Number.isFinite(checkedAtValue) ? checkedAtValue : Date.now();
+
+  return (parsed.diagnostics ?? []).flatMap<McpServerDiagnostic>((entry) => {
+    if (
+      typeof entry.name !== 'string' ||
+      typeof entry.target !== 'string' ||
+      typeof entry.statusLabel !== 'string'
+    ) {
+      return [];
+    }
+
+    const redactedTarget = redactDiagnosticTarget(entry.target);
+    const normalizedStatus: McpServerHealthStatus =
+      entry.status === 'connected'
+        ? 'connected'
+        : entry.status === 'needs-authentication'
+          ? 'needs-authentication'
+          : entry.status === 'failed' || entry.status === 'timeout'
+            ? 'failed'
+            : 'unknown';
+
+    const rawLine = `${entry.name}: ${redactedTarget} - ${entry.statusLabel}`;
+    const diagnostic = {
+      name: entry.name,
+      target: redactedTarget,
+      scope: entry.scope,
+      transport: entry.transport,
+      status: normalizedStatus,
+      statusLabel: entry.statusLabel,
+      rawLine,
+      checkedAt,
+    } satisfies McpServerDiagnostic;
+
+    return isExtensionsManagedDiagnosticEntry(diagnostic) ? [diagnostic] : [];
+  });
+}

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

@@ -0,0 +1,45 @@
+import { isInstalledMcpScope } from '@shared/utils/mcpScopes';
+
+import type { InstalledMcpEntry } from '@shared/types/extensions';
+
+interface McpListJsonServer {
+  name?: string;
+  scope?: string;
+  transport?: string;
+}
+
+interface McpListJsonPayload {
+  servers?: McpListJsonServer[];
+}
+
+function extractJsonObject<T>(raw: string): T {
+  const trimmed = raw.trim();
+  try {
+    return JSON.parse(trimmed) as T;
+  } catch {
+    const start = trimmed.indexOf('{');
+    const end = trimmed.lastIndexOf('}');
+    if (start >= 0 && end > start) {
+      return JSON.parse(trimmed.slice(start, end + 1)) as T;
+    }
+    throw new Error('No JSON object found in CLI output');
+  }
+}
+
+export function parseInstalledMcpJsonOutput(output: string): InstalledMcpEntry[] {
+  const parsed = extractJsonObject<McpListJsonPayload>(output);
+
+  return (parsed.servers ?? []).flatMap<InstalledMcpEntry>((entry) => {
+    if (typeof entry.name !== 'string' || !isInstalledMcpScope(entry.scope)) {
+      return [];
+    }
+
+    return [
+      {
+        name: entry.name,
+        scope: entry.scope,
+        transport: typeof entry.transport === 'string' ? entry.transport : undefined,
+      },
+    ];
+  });
+}

package/src/main/services/extensions/skills/SkillImportService.ts

@@ -0,0 +1,155 @@
+import * as fs from 'node:fs/promises';
+import * as path from 'node:path';
+
+import { validateOpenPathUserSelected } from '@main/utils/pathValidation';
+import { isBinaryFile } from 'isbinaryfile';
+
+import { SkillScanner } from './SkillScanner';
+
+export interface ImportedSkillSourceFile {
+  relativePath: string;
+  absolutePath: string;
+  content: string | null;
+  isBinary: boolean;
+}
+
+export interface SkillImportInspection {
+  files: ImportedSkillSourceFile[];
+  warnings: string[];
+  hiddenEntriesSkipped: number;
+}
+
+const MAX_IMPORT_FILE_COUNT = 200;
+const MAX_IMPORT_TOTAL_BYTES = 10 * 1024 * 1024;
+
+export class SkillImportService {
+  constructor(private readonly scanner = new SkillScanner()) {}
+
+  async validateSourceDir(sourceDir: string): Promise<string> {
+    const validatedSource = validateOpenPathUserSelected(sourceDir);
+    if (!validatedSource.valid || !validatedSource.normalizedPath) {
+      throw new Error(validatedSource.error ?? 'Invalid import source');
+    }
+
+    const normalizedSourceDir = validatedSource.normalizedPath;
+    const sourceStat = await fs.stat(normalizedSourceDir);
+    if (!sourceStat.isDirectory()) {
+      throw new Error('Import source must be a directory');
+    }
+
+    const detectedSkillFile = await this.scanner.detectSkillFile(normalizedSourceDir);
+    if (!detectedSkillFile) {
+      throw new Error('Import source does not contain a valid skill file');
+    }
+
+    return normalizedSourceDir;
+  }
+
+  async inspectSourceDir(sourceDir: string): Promise<SkillImportInspection> {
+    const normalizedSourceDir = await this.validateSourceDir(sourceDir);
+    const walked = await this.walkDirectory(normalizedSourceDir);
+    const files = await Promise.all(
+      walked.files.map(async ({ absolutePath, relativePath }) => {
+        const binary = await isBinaryFile(absolutePath);
+        return {
+          relativePath,
+          absolutePath,
+          content: binary ? null : await fs.readFile(absolutePath, 'utf8'),
+          isBinary: binary,
+        };
+      })
+    );
+
+    const warnings: string[] = [];
+    if (walked.hiddenEntriesSkipped > 0) {
+      warnings.push('Hidden files and folders were skipped during import.');
+    }
+    if (files.some((file) => file.isBinary)) {
+      warnings.push('This import includes binary files. Binary files will be copied as-is.');
+    }
+    if (
+      files.some(
+        (file) => file.relativePath === 'scripts' || file.relativePath.startsWith('scripts/')
+      )
+    ) {
+      warnings.push('This import includes scripts. Review them carefully before importing.');
+    }
+
+    return {
+      files,
+      warnings,
+      hiddenEntriesSkipped: walked.hiddenEntriesSkipped,
+    };
+  }
+
+  async readSourceFiles(sourceDir: string): Promise<ImportedSkillSourceFile[]> {
+    return (await this.inspectSourceDir(sourceDir)).files;
+  }
+
+  async writeImportedFiles(
+    targetSkillDir: string,
+    files: ImportedSkillSourceFile[]
+  ): Promise<void> {
+    for (const file of files) {
+      const destPath = path.join(targetSkillDir, file.relativePath);
+      await fs.mkdir(path.dirname(destPath), { recursive: true });
+      if (file.isBinary) {
+        await fs.copyFile(file.absolutePath, destPath);
+      } else {
+        await fs.writeFile(destPath, file.content ?? '', 'utf8');
+      }
+    }
+  }
+
+  private async walkDirectory(rootDir: string): Promise<{
+    files: { absolutePath: string; relativePath: string }[];
+    hiddenEntriesSkipped: number;
+  }> {
+    const allFiles: { absolutePath: string; relativePath: string }[] = [];
+    let hiddenEntriesSkipped = 0;
+    let totalBytes = 0;
+
+    const visit = async (currentDir: string): Promise<void> => {
+      const dirEntries = await fs.readdir(currentDir, { withFileTypes: true });
+      for (const entry of dirEntries) {
+        if (entry.name.startsWith('.')) {
+          hiddenEntriesSkipped += 1;
+          continue;
+        }
+
+        const fullPath = path.join(currentDir, entry.name);
+        if (entry.isSymbolicLink()) {
+          throw new Error('Import source cannot contain symbolic links');
+        }
+
+        if (entry.isDirectory()) {
+          await visit(fullPath);
+          continue;
+        }
+
+        const stat = await fs.stat(fullPath);
+        totalBytes += stat.size;
+        if (allFiles.length + 1 > MAX_IMPORT_FILE_COUNT) {
+          throw new Error(`Import source has too many files (max ${MAX_IMPORT_FILE_COUNT})`);
+        }
+        if (totalBytes > MAX_IMPORT_TOTAL_BYTES) {
+          throw new Error(
+            `Import source is too large (max ${Math.floor(MAX_IMPORT_TOTAL_BYTES / (1024 * 1024))} MB)`
+          );
+        }
+
+        allFiles.push({
+          absolutePath: fullPath,
+          relativePath: path.relative(rootDir, fullPath).replace(/\\/g, '/'),
+        });
+      }
+    };
+
+    await visit(rootDir);
+
+    return {
+      files: allFiles.sort((a, b) => a.relativePath.localeCompare(b.relativePath)),
+      hiddenEntriesSkipped,
+    };
+  }
+}