codex-linux 1.0.0

package/src/main/plugins/PluginMarketplace.ts

@@ -0,0 +1,318 @@
+import { EventEmitter } from 'events';
+import { v4 as uuidv4 } from 'uuid';
+import * as path from 'path';
+import * as fs from 'fs/promises';
+import log from 'electron-log';
+import fetch from 'node-fetch';
+
+export type PluginPermission = 
+  | 'file:read'
+  | 'file:write'
+  | 'file:delete'
+  | 'command:execute'
+  | 'network:request'
+  | 'storage:read'
+  | 'storage:write'
+  | 'agent:create'
+  | 'agent:control'
+  | 'ui:render'
+  | 'clipboard:read'
+  | 'clipboard:write';
+
+export interface PluginMarketplaceItem {
+  id: string;
+  name: string;
+  description: string;
+  version: string;
+  author: string;
+  authorUrl?: string;
+  homepage?: string;
+  repository?: string;
+  license: string;
+  keywords: string[];
+  downloads: number;
+  rating: number;
+  createdAt: Date;
+  updatedAt: Date;
+  iconUrl?: string;
+  manifest: Record<string, unknown>;
+}
+
+export interface PluginPermissionRequest {
+  pluginId: string;
+  permissions: PluginPermission[];
+  reason: string;
+}
+
+export interface PluginInstallOptions {
+  version?: string;
+  force?: boolean;
+  dependencies?: boolean;
+}
+
+export interface PluginSecurityPolicy {
+  allowedHosts?: string[];
+  allowedCommands?: string[];
+  sandboxed?: boolean;
+  maxMemory?: number;
+  maxCpu?: number;
+}
+
+export class PluginMarketplace extends EventEmitter {
+  private marketplaceUrl: string;
+  private cache: Map<string, { data: PluginMarketplaceItem; expiresAt: Date }> = new Map();
+  private cacheTimeout = 15 * 60 * 1000;
+
+  constructor(marketplaceUrl: string = 'https://marketplace.codex-linux.dev/api') {
+    super();
+    this.marketplaceUrl = marketplaceUrl;
+  }
+
+  configure(marketplaceUrl: string): void {
+    this.marketplaceUrl = marketplaceUrl;
+    log.info('PluginMarketplace configured', { url: marketplaceUrl });
+  }
+
+  private getCache(key: string): PluginMarketplaceItem | null {
+    const cached = this.cache.get(key);
+    if (cached && cached.expiresAt > new Date()) {
+      return cached.data;
+    }
+    this.cache.delete(key);
+    return null;
+  }
+
+  private setCache(key: string, data: PluginMarketplaceItem): void {
+    this.cache.set(key, {
+      data,
+      expiresAt: new Date(Date.now() + this.cacheTimeout),
+    });
+  }
+
+  async search(query: string, options?: {
+    category?: string;
+    sort?: 'popular' | 'recent' | 'rating';
+    limit?: number;
+  }): Promise<PluginMarketplaceItem[]> {
+    const cacheKey = `search:${query}:${JSON.stringify(options)}`;
+    const cached = this.getCache(cacheKey);
+    if (cached) return [cached];
+
+    try {
+      const params = new URLSearchParams({
+        q: query,
+        ...(options?.category && { category: options.category }),
+        sort: options?.sort || 'popular',
+        limit: String(options?.limit || 20),
+      });
+
+      const response = await fetch(`${this.marketplaceUrl}/plugins?${params}`, {
+        headers: { 'User-Agent': 'CodexLinux/1.0' },
+      });
+
+      if (!response.ok) {
+        throw new Error(`Marketplace API error: ${response.statusText}`);
+      }
+
+      const data = await response.json() as { plugins: PluginMarketplaceItem[] };
+      
+      data.plugins.forEach((plugin) => this.setCache(plugin.id, plugin));
+      
+      return data.plugins;
+    } catch (error) {
+      log.error('Failed to search marketplace:', error);
+      return this.mockSearch(query);
+    }
+  }
+
+  async getPlugin(pluginId: string): Promise<PluginMarketplaceItem | null> {
+    const cached = this.getCache(pluginId);
+    if (cached) return cached;
+
+    try {
+      const response = await fetch(`${this.marketplaceUrl}/plugins/${pluginId}`, {
+        headers: { 'User-Agent': 'CodexLinux/1.0' },
+      });
+
+      if (!response.ok) {
+        if (response.status === 404) return null;
+        throw new Error(`Marketplace API error: ${response.statusText}`);
+      }
+
+      const data = await response.json() as PluginMarketplaceItem;
+      this.setCache(pluginId, data);
+      return data;
+    } catch (error) {
+      log.error('Failed to get plugin:', error);
+      return null;
+    }
+  }
+
+  async getCategories(): Promise<string[]> {
+    try {
+      const response = await fetch(`${this.marketplaceUrl}/categories`, {
+        headers: { 'User-Agent': 'CodexLinux/1.0' },
+      });
+
+      if (!response.ok) {
+        throw new Error(`Marketplace API error: ${response.statusText}`);
+      }
+
+      const data = await response.json() as { categories: string[] };
+      return data.categories;
+    } catch (error) {
+      log.error('Failed to get categories:', error);
+      return ['AI Agents', 'Productivity', 'Integrations', 'Themes', 'Utilities'];
+    }
+  }
+
+  async getFeatured(): Promise<PluginMarketplaceItem[]> {
+    try {
+      const response = await fetch(`${this.marketplaceUrl}/featured`, {
+        headers: { 'User-Agent': 'CodexLinux/1.0' },
+      });
+
+      if (!response.ok) {
+        throw new Error(`Marketplace API error: ${response.statusText}`);
+      }
+
+      const data = await response.json() as { plugins: PluginMarketplaceItem[] };
+      return data.plugins;
+    } catch (error) {
+      log.error('Failed to get featured plugins:', error);
+      return [];
+    }
+  }
+
+  private mockSearch(query: string): PluginMarketplaceItem[] {
+    return [
+      {
+        id: 'github-integration',
+        name: 'GitHub Integration',
+        description: 'Seamless GitHub integration for PRs, issues, and workflows',
+        version: '1.0.0',
+        author: 'Codex Team',
+        license: 'MIT',
+        keywords: ['github', 'git', 'integration'],
+        downloads: 15000,
+        rating: 4.8,
+        createdAt: new Date('2024-01-01'),
+        updatedAt: new Date('2024-06-15'),
+        manifest: {},
+      },
+      {
+        id: 'slack-notifications',
+        name: 'Slack Notifications',
+        description: 'Get agent updates directly in Slack',
+        version: '1.2.0',
+        author: 'Codex Team',
+        license: 'MIT',
+        keywords: ['slack', 'notifications'],
+        downloads: 8000,
+        rating: 4.5,
+        createdAt: new Date('2024-02-01'),
+        updatedAt: new Date('2024-07-01'),
+        manifest: {},
+      },
+    ];
+  }
+
+  clearCache(): void {
+    this.cache.clear();
+    this.emit('cache:cleared');
+  }
+
+  cleanup(): void {
+    this.cache.clear();
+    this.removeAllListeners();
+  }
+}
+
+export class PluginPermissionManager extends EventEmitter {
+  private permissions: Map<string, Set<PluginPermission>> = new Map();
+  private pendingRequests: Map<string, PluginPermissionRequest> = new Map();
+  private defaultPermissions: PluginPermission[] = [
+    'storage:read',
+    'storage:write',
+    'ui:render',
+  ];
+
+  constructor() {
+    super();
+  }
+
+  requestPermissions(pluginId: string, permissions: PluginPermission[], reason: string): string {
+    const requestId = uuidv4();
+    this.pendingRequests.set(requestId, {
+      pluginId,
+      permissions,
+      reason,
+    });
+    this.emit('permission:requested', { requestId, pluginId, permissions });
+    return requestId;
+  }
+
+  async approvePermissions(requestId: string): Promise<boolean> {
+    const request = this.pendingRequests.get(requestId);
+    if (!request) return false;
+
+    if (!this.permissions.has(request.pluginId)) {
+      this.permissions.set(request.pluginId, new Set(this.defaultPermissions));
+    }
+
+    const pluginPerms = this.permissions.get(request.pluginId)!;
+    request.permissions.forEach((p) => pluginPerms.add(p));
+
+    this.pendingRequests.delete(requestId);
+    this.emit('permission:approved', { requestId, pluginId: request.pluginId });
+    log.info(`Permissions approved for plugin ${request.pluginId}`);
+    return true;
+  }
+
+  rejectPermissions(requestId: string): boolean {
+    const request = this.pendingRequests.get(requestId);
+    if (!request) return false;
+
+    this.pendingRequests.delete(requestId);
+    this.emit('permission:rejected', { requestId, pluginId: request.pluginId });
+    return true;
+  }
+
+  getPermissions(pluginId: string): PluginPermission[] {
+    return Array.from(this.permissions.get(pluginId) || new Set(this.defaultPermissions));
+  }
+
+  hasPermission(pluginId: string, permission: PluginPermission): boolean {
+    const pluginPerms = this.permissions.get(pluginId);
+    if (!pluginPerms) return this.defaultPermissions.includes(permission);
+    return pluginPerms.has(permission);
+  }
+
+  revokePermission(pluginId: string, permission: PluginPermission): boolean {
+    const pluginPerms = this.permissions.get(pluginId);
+    if (!pluginPerms) return false;
+    
+    const removed = pluginPerms.delete(permission);
+    if (removed) {
+      this.emit('permission:revoked', { pluginId, permission });
+    }
+    return removed;
+  }
+
+  revokeAllPermissions(pluginId: string): void {
+    this.permissions.delete(pluginId);
+    this.emit('permissions:revoked', { pluginId });
+  }
+
+  getPendingRequests(): PluginPermissionRequest[] {
+    return Array.from(this.pendingRequests.values());
+  }
+
+  cleanup(): void {
+    this.permissions.clear();
+    this.pendingRequests.clear();
+    this.removeAllListeners();
+  }
+}
+
+export default PluginMarketplace;

package/src/main/preload.ts

@@ -0,0 +1,215 @@
+import { contextBridge, ipcRenderer } from 'electron';
+
+// Expose protected methods that allow the renderer process to use
+// the ipcRenderer without exposing the entire object
+contextBridge.exposeInMainWorld('electronAPI', {
+  // Window controls
+  window: {
+    minimize: () => ipcRenderer.invoke('window:minimize'),
+    maximize: () => ipcRenderer.invoke('window:maximize'),
+    close: () => ipcRenderer.invoke('window:close'),
+  },
+
+  // Dialog operations
+  dialog: {
+    selectFolder: () => ipcRenderer.invoke('dialog:selectFolder'),
+    selectFile: (filters?: Electron.FileFilter[]) => ipcRenderer.invoke('dialog:selectFile', filters),
+  },
+
+  // Shell operations
+  shell: {
+    openExternal: (url: string) => ipcRenderer.invoke('shell:openExternal', url),
+    openPath: (path: string) => ipcRenderer.invoke('shell:openPath', path),
+  },
+
+  // Agent operations
+  agent: {
+    create: (config: any) => ipcRenderer.invoke('agent:create', config),
+    list: () => ipcRenderer.invoke('agent:list'),
+    get: (agentId: string) => ipcRenderer.invoke('agent:get', agentId),
+    sendMessage: (agentId: string, message: string) => ipcRenderer.invoke('agent:sendMessage', agentId, message),
+    sendMessageStream: (agentId: string, message: string) => ipcRenderer.invoke('agent:sendMessageStream', agentId, message),
+    executeTask: (agentId: string, task: string) => ipcRenderer.invoke('agent:executeTask', agentId, task),
+    pause: (agentId: string) => ipcRenderer.invoke('agent:pause', agentId),
+    resume: (agentId: string) => ipcRenderer.invoke('agent:resume', agentId),
+    stop: (agentId: string) => ipcRenderer.invoke('agent:stop', agentId),
+    delete: (agentId: string) => ipcRenderer.invoke('agent:delete', agentId),
+  },
+
+  // Cowork operations
+  cowork: {
+    create: (name: string, objective: string, projectPath: string, options?: any) => ipcRenderer.invoke('cowork:create', name, objective, projectPath, options),
+    start: (sessionId: string) => ipcRenderer.invoke('cowork:start', sessionId),
+    pause: (sessionId: string) => ipcRenderer.invoke('cowork:pause', sessionId),
+    stop: (sessionId: string) => ipcRenderer.invoke('cowork:stop', sessionId),
+    list: () => ipcRenderer.invoke('cowork:list'),
+  },
+
+  // Pair programming operations
+  pair: {
+    start: (projectPath: string, mode: string, userId: string) => ipcRenderer.invoke('pair:start', projectPath, mode, userId),
+    chat: (sessionId: string, message: string) => ipcRenderer.invoke('pair:chat', sessionId, message),
+    end: (sessionId: string) => ipcRenderer.invoke('pair:end', sessionId),
+  },
+
+  // Smart code assistant
+  assistant: {
+    inlineCompletion: (filePath: string, content: string, position: any) => ipcRenderer.invoke('assistant:inlineCompletion', filePath, content, position),
+    suggestFixes: (filePath: string, content: string) => ipcRenderer.invoke('assistant:suggestFixes', filePath, content),
+    explain: (code: string) => ipcRenderer.invoke('assistant:explain', code),
+  },
+
+  // Metrics operations
+  metrics: {
+    get: () => ipcRenderer.invoke('metrics:get'),
+    export: () => ipcRenderer.invoke('metrics:export'),
+  },
+
+  // Worktree operations
+  worktree: {
+    create: (repoPath: string, name: string) => ipcRenderer.invoke('worktree:create', repoPath, name),
+    list: (repoPath: string) => ipcRenderer.invoke('worktree:list', repoPath),
+    remove: (repoPath: string, name: string) => ipcRenderer.invoke('worktree:remove', repoPath, name),
+  },
+
+  // Skills operations
+  skills: {
+    list: () => ipcRenderer.invoke('skills:list'),
+    get: (skillId: string) => ipcRenderer.invoke('skills:get', skillId),
+    create: (config: any) => ipcRenderer.invoke('skills:create', config),
+    update: (skillId: string, config: any) => ipcRenderer.invoke('skills:update', skillId, config),
+    delete: (skillId: string) => ipcRenderer.invoke('skills:delete', skillId),
+    applyToAgent: (agentId: string, skillIds: string[]) => ipcRenderer.invoke('skills:applyToAgent', agentId, skillIds),
+  },
+
+  // Automation operations
+  automation: {
+    list: () => ipcRenderer.invoke('automation:list'),
+    create: (config: any) => ipcRenderer.invoke('automation:create', config),
+    update: (automationId: string, config: any) => ipcRenderer.invoke('automation:update', automationId, config),
+    delete: (automationId: string) => ipcRenderer.invoke('automation:delete', automationId),
+    toggle: (automationId: string, enabled: boolean) => ipcRenderer.invoke('automation:toggle', automationId, enabled),
+  },
+
+  // Settings operations
+  settings: {
+    get: (key: string) => ipcRenderer.invoke('settings:get', key),
+    set: (key: string, value: any) => ipcRenderer.invoke('settings:set', key, value),
+    getAll: () => ipcRenderer.invoke('settings:getAll'),
+  },
+
+  // AI Provider operations
+  providers: {
+    list: () => ipcRenderer.invoke('providers:list'),
+    getActive: () => ipcRenderer.invoke('providers:getActive'),
+    setActive: (providerId: string) => ipcRenderer.invoke('providers:setActive', providerId),
+    configure: (providerId: string, config: any) => ipcRenderer.invoke('providers:configure', providerId, config),
+    test: (providerId: string) => ipcRenderer.invoke('providers:test', providerId),
+  },
+
+  // File system operations
+  fs: {
+    readdir: (path: string, options?: { withFileTypes?: boolean }) => ipcRenderer.invoke('fs:readdir', path, options),
+    readFile: (path: string, encoding?: BufferEncoding) => ipcRenderer.invoke('fs:readFile', path, encoding),
+    writeFile: (path: string, content: string) => ipcRenderer.invoke('fs:writeFile', path, content),
+    stat: (path: string) => ipcRenderer.invoke('fs:stat', path),
+  },
+
+  // Terminal operations
+  terminal: {
+    execute: ({ command, cwd }: { command: string; cwd: string }) => ipcRenderer.invoke('terminal:execute', { command, cwd }),
+    kill: () => ipcRenderer.invoke('terminal:kill'),
+  },
+
+  // Code changes operations
+  changes: {
+    list: (agentId?: string) => ipcRenderer.invoke('changes:list', agentId),
+    approve: (changeId: string) => ipcRenderer.invoke('changes:approve', changeId),
+    reject: (changeId: string, comment?: string) => ipcRenderer.invoke('changes:reject', changeId, comment),
+    apply: (changeId: string) => ipcRenderer.invoke('changes:apply', changeId),
+  },
+
+  // Checkpoints operations
+  checkpoints: {
+    list: (agentId?: string) => ipcRenderer.invoke('checkpoints:list', agentId),
+    restore: (checkpointId: string) => ipcRenderer.invoke('checkpoints:restore', checkpointId),
+    restoreLast: (agentId: string) => ipcRenderer.invoke('checkpoints:restoreLast', agentId),
+  },
+
+  // Agent queue operations
+  queue: {
+    list: (agentId: string) => ipcRenderer.invoke('queue:list', agentId),
+    enqueue: (agentId: string, type: 'message' | 'task', content: string) => ipcRenderer.invoke('queue:enqueue', agentId, type, content),
+    delete: (agentId: string, itemId: string) => ipcRenderer.invoke('queue:delete', agentId, itemId),
+    moveUp: (agentId: string, itemId: string) => ipcRenderer.invoke('queue:moveUp', agentId, itemId),
+    claimNext: (agentId: string) => ipcRenderer.invoke('queue:claimNext', agentId),
+    complete: (agentId: string, itemId: string, outcome: 'completed' | 'failed', error?: string) => ipcRenderer.invoke('queue:complete', agentId, itemId, outcome, error),
+    history: (agentId: string, limit?: number) => ipcRenderer.invoke('queue:history', agentId, limit),
+  },
+
+  // Audit log operations
+  audit: {
+    recent: (limit?: number) => ipcRenderer.invoke('audit:recent', limit),
+    byAction: (action: string, limit?: number) => ipcRenderer.invoke('audit:byAction', action, limit),
+    export: (exportPath: string) => ipcRenderer.invoke('audit:export', exportPath),
+  },
+
+  // Git operations
+  git: {
+    status: (repoPath: string) => ipcRenderer.invoke('git:status', repoPath),
+    commit: ({ repoPath, message, files }: { repoPath: string; message: string; files?: string[] }) => ipcRenderer.invoke('git:commit', { repoPath, message, files }),
+    diff: ({ repoPath, filePath }: { repoPath: string; filePath?: string }) => ipcRenderer.invoke('git:diff', { repoPath, filePath }),
+  },
+
+  // Search operations
+  search: {
+    files: ({ query, path, pattern }: { query: string; path: string; pattern?: string }) => ipcRenderer.invoke('search:files', { query, path, pattern }),
+  },
+
+  // Notifications
+  notification: {
+    show: ({ title, body }: { title: string; body: string }) => ipcRenderer.invoke('notification:show', { title, body }),
+  },
+
+  // Export/Import
+  data: {
+    export: (exportPath: string) => ipcRenderer.invoke('data:export', exportPath),
+    import: (importPath: string) => ipcRenderer.invoke('data:import', importPath),
+  },
+
+  // Event listeners
+  on: (channel: string, callback: (...args: any[]) => void) => {
+    const validChannels = [
+      'agent:message',
+      'agent:status',
+      'agent:progress',
+      'agent:error',
+      'agent:streamChunk',
+      'agent:streamEnd',
+      'agent:streamError',
+      'agent:taskStarted',
+      'agent:taskCompleted',
+      'agent:taskFailed',
+      'agent:paused',
+      'agent:resumed',
+      'agent:stopped',
+      'changes:created',
+      'automation:triggered',
+      'worktree:changed',
+      'skill:applied',
+      'terminal:data',
+      'notification:show'
+    ];
+    if (validChannels.includes(channel)) {
+      ipcRenderer.on(channel, callback);
+    }
+  },
+
+  removeListener: (channel: string, callback: (...args: any[]) => void) => {
+    ipcRenderer.removeListener(channel, callback);
+  },
+});
+
+export type ElectronAPI = {
+  // Define the type without referencing window
+};