codex-linux 1.0.0

package/src/main/mcp/MCPRegistry.ts

@@ -0,0 +1,273 @@
+import { EventEmitter } from 'events';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import * as os from 'os';
+import log from 'electron-log';
+import fetch from 'node-fetch';
+import { MCPRegistryEntry, MCPServerDefinition, MCPTransportType, MCPScope } from '../../shared/types';
+
+const ANTHROPIC_MCP_REGISTRY_URL = 'https://api.anthropic.com/mcp-registry/v0';
+const MCP_CACHE_DIR = path.join(os.homedir(), '.cache', 'codex', 'mcp');
+
+export class MCPRegistry extends EventEmitter {
+  private registryCache: Map<string, MCPRegistryEntry> = new Map();
+  private lastSync: Date | null = null;
+  private readonly CACHE_TTL = 24 * 60 * 60 * 1000; // 24 hours
+
+  async initialize(): Promise<void> {
+    await this.ensureCacheDir();
+    await this.loadCachedRegistry();
+    log.info('MCP Registry initialized');
+  }
+
+  private async ensureCacheDir(): Promise<void> {
+    try {
+      await fs.mkdir(MCP_CACHE_DIR, { recursive: true });
+    } catch (error) {
+      log.error('Failed to create MCP cache directory:', error);
+    }
+  }
+
+  private async loadCachedRegistry(): Promise<void> {
+    try {
+      const cacheFile = path.join(MCP_CACHE_DIR, 'registry-cache.json');
+      const data = await fs.readFile(cacheFile, 'utf-8');
+      const cached = JSON.parse(data);
+      
+      if (cached.entries && Array.isArray(cached.entries)) {
+        for (const entry of cached.entries) {
+          this.registryCache.set(entry.id, entry);
+        }
+        this.lastSync = new Date(cached.timestamp);
+        log.info(`Loaded ${this.registryCache.size} MCP servers from cache`);
+      }
+    } catch (error) {
+      // Cache doesn't exist or is invalid
+      log.debug('No MCP registry cache found');
+    }
+  }
+
+  private async saveCache(): Promise<void> {
+    try {
+      const cacheFile = path.join(MCP_CACHE_DIR, 'registry-cache.json');
+      const data = {
+        timestamp: new Date().toISOString(),
+        entries: Array.from(this.registryCache.values()),
+      };
+      await fs.writeFile(cacheFile, JSON.stringify(data, null, 2));
+    } catch (error) {
+      log.error('Failed to save MCP registry cache:', error);
+    }
+  }
+
+  async syncWithRemote(): Promise<void> {
+    try {
+      log.info('Syncing MCP registry with Anthropic...');
+      
+      // Fetch from Anthropic's official registry
+      const response = await fetch(`${ANTHROPIC_MCP_REGISTRY_URL}/servers?version=latest&visibility=commercial&limit=100`, {
+        headers: {
+          'Accept': 'application/json',
+        },
+      });
+
+      if (!response.ok) {
+        throw new Error(`Registry sync failed: ${response.status}`);
+      }
+
+      const data: any = await response.json();
+      
+      if (data.servers && Array.isArray(data.servers)) {
+        for (const item of data.servers) {
+          const server = item.server;
+          const meta = item._meta?.['com.anthropic.api/mcp-registry'] || {};
+          
+          const entry: MCPRegistryEntry = {
+            id: server.name || server.id,
+            name: meta.displayName || server.title || server.name,
+            description: meta.oneLiner || server.description,
+            publisher: meta.publisher || 'Unknown',
+            version: server.version || '1.0.0',
+            transport: server.remotes?.map((r: any) => r.type) || ['stdio'],
+            categories: meta.categories || [],
+            tags: meta.tags || [],
+            installs: meta.installs || 0,
+            rating: meta.rating || 0,
+            documentation: meta.documentation || server.documentation,
+            repository: server.repository,
+            packages: server.packages,
+            remotes: server.remotes,
+            environmentVariables: server.packages?.[0]?.environmentVariables,
+          };
+
+          this.registryCache.set(entry.id, entry);
+        }
+
+        this.lastSync = new Date();
+        await this.saveCache();
+        
+        log.info(`Synced ${this.registryCache.size} MCP servers from registry`);
+        this.emit('registry:synced', { count: this.registryCache.size });
+      }
+    } catch (error) {
+      log.error('Failed to sync MCP registry:', error);
+      this.emit('registry:syncError', error);
+      
+      // Use cached data if available
+      if (this.registryCache.size > 0) {
+        log.warn('Using cached MCP registry data');
+      }
+    }
+  }
+
+  async search(query: string, filters?: {
+    category?: string;
+    transport?: MCPTransportType;
+    tags?: string[];
+  }): Promise<MCPRegistryEntry[]> {
+    const results: MCPRegistryEntry[] = [];
+    const lowerQuery = query.toLowerCase();
+
+    for (const entry of this.registryCache.values()) {
+      // Text search
+      const matchesQuery = 
+        entry.name.toLowerCase().includes(lowerQuery) ||
+        entry.description.toLowerCase().includes(lowerQuery) ||
+        entry.tags.some(tag => tag.toLowerCase().includes(lowerQuery));
+
+      if (!matchesQuery) continue;
+
+      // Apply filters
+      if (filters?.category && !entry.categories.includes(filters.category)) {
+        continue;
+      }
+
+      if (filters?.transport && !entry.transport.includes(filters.transport)) {
+        continue;
+      }
+
+      if (filters?.tags && !filters.tags.every(tag => entry.tags.includes(tag))) {
+        continue;
+      }
+
+      results.push(entry);
+    }
+
+    // Sort by relevance (installs and rating)
+    results.sort((a, b) => {
+      const scoreA = (a.installs * 0.7) + (a.rating * 100 * 0.3);
+      const scoreB = (b.installs * 0.7) + (b.rating * 100 * 0.3);
+      return scoreB - scoreA;
+    });
+
+    return results;
+  }
+
+  getEntry(id: string): MCPRegistryEntry | undefined {
+    return this.registryCache.get(id);
+  }
+
+  getAllCategories(): string[] {
+    const categories = new Set<string>();
+    for (const entry of this.registryCache.values()) {
+      entry.categories.forEach(cat => categories.add(cat));
+    }
+    return Array.from(categories).sort();
+  }
+
+  getPopularEntries(limit: number = 10): MCPRegistryEntry[] {
+    return Array.from(this.registryCache.values())
+      .sort((a, b) => b.installs - a.installs)
+      .slice(0, limit);
+  }
+
+  getTopRated(limit: number = 10): MCPRegistryEntry[] {
+    return Array.from(this.registryCache.values())
+      .filter(e => e.rating > 0)
+      .sort((a, b) => b.rating - a.rating)
+      .slice(0, limit);
+  }
+
+  async generateServerConfig(
+    entryId: string,
+    options: {
+      scope?: MCPScope;
+      envVars?: Record<string, string>;
+      customUrl?: string;
+    } = {}
+  ): Promise<MCPServerDefinition | null> {
+    const entry = this.registryCache.get(entryId);
+    if (!entry) return null;
+
+    const config: MCPServerDefinition = {
+      id: entryId,
+      name: entry.name,
+      description: entry.description,
+      transport: this.determineTransport(entry),
+      scope: options.scope || 'local',
+    };
+
+    // Determine transport and configuration
+    if (config.transport === 'http' && entry.remotes) {
+      const httpRemote = entry.remotes.find(r => r.type === 'streamable-http');
+      if (httpRemote) {
+        config.url = options.customUrl || httpRemote.url;
+      }
+    } else if (config.transport === 'sse' && entry.remotes) {
+      const sseRemote = entry.remotes.find(r => r.type === 'sse');
+      if (sseRemote) {
+        config.url = options.customUrl || sseRemote.url;
+      }
+    } else if (entry.packages) {
+      // Stdio transport via npm package
+      const npmPackage = entry.packages.find(p => p.registryType === 'npm');
+      if (npmPackage) {
+        config.command = 'npx';
+        config.args = ['-y', npmPackage.identifier];
+      }
+    }
+
+    // Add environment variables
+    if (entry.environmentVariables) {
+      config.env = {};
+      for (const envVar of entry.environmentVariables) {
+        if (options.envVars?.[envVar.name]) {
+          config.env[envVar.name] = options.envVars[envVar.name];
+        }
+      }
+    }
+
+    // Add metadata
+    config.metadata = {
+      category: entry.categories[0],
+      tags: entry.tags,
+      author: entry.publisher,
+      version: entry.version,
+      homepage: entry.documentation,
+    };
+
+    return config;
+  }
+
+  private determineTransport(entry: MCPRegistryEntry): MCPTransportType {
+    if (entry.transport.includes('streamable-http')) return 'http';
+    if (entry.transport.includes('sse')) return 'sse';
+    if (entry.transport.includes('websocket')) return 'websocket';
+    return 'stdio';
+  }
+
+  async needsSync(): Promise<boolean> {
+    if (!this.lastSync) return true;
+    return (new Date().getTime() - this.lastSync.getTime()) > this.CACHE_TTL;
+  }
+
+  getLastSyncTime(): Date | null {
+    return this.lastSync;
+  }
+
+  getCacheSize(): number {
+    return this.registryCache.size;
+  }
+}
+
+export const mcpRegistry = new MCPRegistry();

package/src/main/monitoring/ErrorRecoveryManager.ts

@@ -0,0 +1,359 @@
+import { EventEmitter } from 'events';
+import { v4 as uuidv4 } from 'uuid';
+import log from 'electron-log';
+
+export type ErrorSeverity = 'low' | 'medium' | 'high' | 'critical';
+export type RecoveryStrategy = 'retry' | 'fallback' | 'graceful_degradation' | 'ignore' | 'escalate';
+export type ErrorCategory = 'network' | 'timeout' | 'authentication' | 'rate_limit' | 'validation' | 'system' | 'unknown';
+
+export interface ErrorContext {
+  timestamp: Date;
+  service: string;
+  operation: string;
+  metadata?: Record<string, unknown>;
+}
+
+export interface TrackedError {
+  id: string;
+  name: string;
+  message: string;
+  stack?: string;
+  category: ErrorCategory;
+  severity: ErrorSeverity;
+  context: ErrorContext;
+  recoveryStrategy: RecoveryStrategy;
+  retryCount: number;
+  maxRetries: number;
+  resolved: boolean;
+  resolvedAt?: Date;
+}
+
+export interface RecoveryConfig {
+  maxRetries: number;
+  baseDelay: number;
+  maxDelay: number;
+  exponentialBackoff: boolean;
+  enableAutoRecovery: boolean;
+}
+
+export interface ErrorStats {
+  totalErrors: number;
+  byCategory: Record<ErrorCategory, number>;
+  bySeverity: Record<ErrorSeverity, number>;
+  resolved: number;
+  unresolved: number;
+  recoverySuccessRate: number;
+}
+
+export class ErrorRecoveryManager extends EventEmitter {
+  private errors: Map<string, TrackedError> = new Map();
+  private config: RecoveryConfig;
+  private recoveryQueue: Map<string, NodeJS.Timeout> = new Map();
+
+  constructor(config?: Partial<RecoveryConfig>) {
+    super();
+    this.config = {
+      maxRetries: config?.maxRetries || 3,
+      baseDelay: config?.baseDelay || 1000,
+      maxDelay: config?.maxDelay || 30000,
+      exponentialBackoff: config?.exponentialBackoff ?? true,
+      enableAutoRecovery: config?.enableAutoRecovery ?? true,
+    };
+  }
+
+  configure(config: Partial<RecoveryConfig>): void {
+    this.config = { ...this.config, ...config };
+    log.info('ErrorRecoveryManager configured', this.config);
+  }
+
+  getConfig(): RecoveryConfig {
+    return { ...this.config };
+  }
+
+  private categorizeError(error: Error | string): ErrorCategory {
+    const message = typeof error === 'string' ? error : error.message;
+    const lowerMessage = message.toLowerCase();
+
+    if (lowerMessage.includes('network') || lowerMessage.includes('fetch') || lowerMessage.includes('enosys')) {
+      return 'network';
+    }
+    if (lowerMessage.includes('timeout') || lowerMessage.includes('etimedout')) {
+      return 'timeout';
+    }
+    if (lowerMessage.includes('auth') || lowerMessage.includes('token') || lowerMessage.includes('unauthorized')) {
+      return 'authentication';
+    }
+    if (lowerMessage.includes('rate') || lowerMessage.includes('429') || lowerMessage.includes('too many')) {
+      return 'rate_limit';
+    }
+    if (lowerMessage.includes('validation') || lowerMessage.includes('invalid') || lowerMessage.includes('schema')) {
+      return 'validation';
+    }
+    if (lowerMessage.includes('enoent') || lowerMessage.includes('permission') || lowerMessage.includes('eacces')) {
+      return 'system';
+    }
+
+    return 'unknown';
+  }
+
+  private determineSeverity(error: Error | string): ErrorSeverity {
+    const message = typeof error === 'string' ? error : error.message;
+    const lowerMessage = message.toLowerCase();
+
+    if (lowerMessage.includes('fatal') || lowerMessage.includes('critical') || lowerMessage.includes('crash')) {
+      return 'critical';
+    }
+    if (lowerMessage.includes('error') || lowerMessage.includes('failed')) {
+      return 'high';
+    }
+    if (lowerMessage.includes('warn') || lowerMessage.includes('warning')) {
+      return 'medium';
+    }
+
+    return 'low';
+  }
+
+  private determineStrategy(category: ErrorCategory): RecoveryStrategy {
+    switch (category) {
+      case 'network':
+        return 'retry';
+      case 'timeout':
+        return 'retry';
+      case 'authentication':
+        return 'fallback';
+      case 'rate_limit':
+        return 'graceful_degradation';
+      case 'validation':
+        return 'ignore';
+      case 'system':
+        return 'escalate';
+      default:
+        return 'retry';
+    }
+  }
+
+  trackError(
+    error: Error | string,
+    context: ErrorContext,
+    options: {
+      severity?: ErrorSeverity;
+      recoveryStrategy?: RecoveryStrategy;
+      maxRetries?: number;
+    } = {}
+  ): TrackedError {
+    const trackedError: TrackedError = {
+      id: uuidv4(),
+      name: error instanceof Error ? error.name : 'UnknownError',
+      message: typeof error === 'string' ? error : error.message,
+      stack: error instanceof Error ? error.stack : undefined,
+      category: this.categorizeError(error),
+      severity: options.severity || this.determineSeverity(error),
+      context,
+      recoveryStrategy: options.recoveryStrategy || this.determineStrategy(this.categorizeError(error)),
+      retryCount: 0,
+      maxRetries: options.maxRetries || this.config.maxRetries,
+      resolved: false,
+    };
+
+    this.errors.set(trackedError.id, trackedError);
+    this.emit('error:tracked', trackedError);
+    log.error(`Error tracked: ${trackedError.name} in ${context.service}`, {
+      category: trackedError.category,
+      severity: trackedError.severity,
+    });
+
+    if (this.config.enableAutoRecovery) {
+      this.attemptRecovery(trackedError.id);
+    }
+
+    return trackedError;
+  }
+
+  private calculateDelay(error: TrackedError): number {
+    const { baseDelay, maxDelay, exponentialBackoff } = this.config;
+    
+    if (exponentialBackoff) {
+      const delay = Math.min(baseDelay * Math.pow(2, error.retryCount), maxDelay);
+      const jitter = Math.random() * 0.3 * delay;
+      return Math.floor(delay + jitter);
+    }
+
+    return Math.min(baseDelay * (error.retryCount + 1), maxDelay);
+  }
+
+  private attemptRecovery(errorId: string): void {
+    const error = this.errors.get(errorId);
+    if (!error || error.resolved || error.retryCount >= error.maxRetries) {
+      return;
+    }
+
+    const delay = this.calculateDelay(error);
+
+    const timeout = setTimeout(() => {
+      this.recoveryQueue.delete(errorId);
+      this.executeRecovery(errorId);
+    }, delay);
+
+    this.recoveryQueue.set(errorId, timeout);
+    this.emit('recovery:scheduled', { error, delay });
+  }
+
+  private async executeRecovery(errorId: string): Promise<void> {
+    const error = this.errors.get(errorId);
+    if (!error || error.resolved) return;
+
+    error.retryCount++;
+    this.emit('recovery:attempted', { error, attempt: error.retryCount });
+
+    switch (error.recoveryStrategy) {
+      case 'retry':
+        this.emit('recovery:retry', {
+          error,
+          attempt: error.retryCount,
+          maxRetries: error.maxRetries,
+        });
+        break;
+
+      case 'fallback':
+        this.emit('recovery:fallback', { error });
+        break;
+
+      case 'graceful_degradation':
+        this.emit('recovery:degraded', { error });
+        break;
+
+      case 'ignore':
+        this.resolveError(errorId);
+        break;
+
+      case 'escalate':
+        this.emit('recovery:escalated', { error });
+        break;
+    }
+
+    if (error.retryCount < error.maxRetries && !error.resolved) {
+      this.attemptRecovery(errorId);
+    } else if (!error.resolved) {
+      this.emit('recovery:failed', { error });
+    }
+  }
+
+  resolveError(errorId: string, resolved: boolean = true): boolean {
+    const error = this.errors.get(errorId);
+    if (!error) return false;
+
+    error.resolved = resolved;
+    error.resolvedAt = new Date();
+
+    const timeout = this.recoveryQueue.get(errorId);
+    if (timeout) {
+      clearTimeout(timeout);
+      this.recoveryQueue.delete(errorId);
+    }
+
+    this.emit('error:resolved', error);
+    log.info(`Error resolved: ${errorId}`);
+
+    return true;
+  }
+
+  retryNow(errorId: string): boolean {
+    const error = this.errors.get(errorId);
+    if (!error) return false;
+
+    error.retryCount = 0;
+    this.attemptRecovery(errorId);
+
+    return true;
+  }
+
+  getError(id: string): TrackedError | undefined {
+    return this.errors.get(id);
+  }
+
+  getActiveErrors(): TrackedError[] {
+    return Array.from(this.errors.values()).filter((e) => !e.resolved);
+  }
+
+  getErrorsByCategory(category: ErrorCategory): TrackedError[] {
+    return Array.from(this.errors.values()).filter((e) => e.category === category);
+  }
+
+  getErrorsBySeverity(severity: ErrorSeverity): TrackedError[] {
+    return Array.from(this.errors.values()).filter((e) => e.severity === severity);
+  }
+
+  getErrorHistory(limit?: number): TrackedError[] {
+    const all = Array.from(this.errors.values()).sort(
+      (a, b) => b.context.timestamp.getTime() - a.context.timestamp.getTime()
+    );
+    return limit ? all.slice(0, limit) : all;
+  }
+
+  clearResolved(): number {
+    const resolved = Array.from(this.errors.values()).filter((e) => e.resolved);
+    resolved.forEach((e) => this.errors.delete(e.id));
+    
+    const count = resolved.length;
+    if (count > 0) {
+      log.info(`Cleared ${count} resolved errors`);
+    }
+    return count;
+  }
+
+  clearAll(): void {
+    this.recoveryQueue.forEach((timeout) => clearTimeout(timeout));
+    this.recoveryQueue.clear();
+    this.errors.clear();
+    this.emit('errors:cleared');
+    log.info('All errors cleared');
+  }
+
+  getStats(): ErrorStats {
+    const errors = Array.from(this.errors.values());
+    const byCategory: Record<ErrorCategory, number> = {
+      network: 0,
+      timeout: 0,
+      authentication: 0,
+      rate_limit: 0,
+      validation: 0,
+      system: 0,
+      unknown: 0,
+    };
+    const bySeverity: Record<ErrorSeverity, number> = {
+      low: 0,
+      medium: 0,
+      high: 0,
+      critical: 0,
+    };
+
+    let resolved = 0;
+    let recoverySuccess = 0;
+
+    errors.forEach((e) => {
+      byCategory[e.category]++;
+      bySeverity[e.severity]++;
+      if (e.resolved) resolved++;
+      if (e.resolved && e.retryCount > 0) recoverySuccess++;
+    });
+
+    return {
+      totalErrors: errors.length,
+      byCategory,
+      bySeverity,
+      resolved,
+      unresolved: errors.length - resolved,
+      recoverySuccessRate: resolved > 0 ? recoverySuccess / resolved : 0,
+    };
+  }
+
+  cleanup(): void {
+    this.recoveryQueue.forEach((timeout) => clearTimeout(timeout));
+    this.recoveryQueue.clear();
+    this.errors.clear();
+    this.removeAllListeners();
+    log.info('ErrorRecoveryManager cleaned up');
+  }
+}
+
+export default ErrorRecoveryManager;

package/src/main/monitoring/ErrorTracker.ts

@@ -0,0 +1,60 @@
+import { app } from 'electron';
+import log from 'electron-log';
+
+export class ErrorTracker {
+  private isInitialized = false;
+  private dsn?: string;
+
+  initialize(dsn?: string): void {
+    if (!dsn) {
+      log.warn('Error tracking DSN not provided, error tracking disabled');
+      return;
+    }
+
+    this.dsn = dsn;
+    this.isInitialized = true;
+    log.info('Error tracker initialized with DSN:', dsn ? 'configured' : 'none');
+  }
+
+  private shouldIgnoreError(event: any): boolean {
+    if (!event || !event.exception) return false;
+    
+    const ignoredPatterns = [
+      'ResizeObserver',
+      'NetworkError',
+      'chrome-extension'
+    ];
+    
+    const message = JSON.stringify(event.exception);
+    return ignoredPatterns.some(pattern => message.includes(pattern));
+  }
+
+  captureException(error: Error, context?: Record<string, any>): void {
+    if (!this.isInitialized) return;
+    
+    log.error('Captured exception:', error.message, context);
+    
+    if (this.dsn) {
+      // In production, would send to Sentry
+      // For now, just log
+    }
+  }
+
+  captureMessage(message: string, level: 'info' | 'warning' | 'error' = 'info'): void {
+    if (!this.isInitialized) return;
+    
+    log[level]('Captured message:', message);
+  }
+
+  setUser(user: { id: string; email?: string; username?: string }): void {
+    if (!this.isInitialized) return;
+    
+    log.info('Setting user context:', user.id);
+  }
+
+  addBreadcrumb(breadcrumb: { category?: string; message?: string; level?: string }): void {
+    if (!this.isInitialized) return;
+    
+    log.debug('Breadcrumb:', breadcrumb);
+  }
+}