codex-linux 1.0.0

package/src/main/agents/AgentSDK.ts

@@ -0,0 +1,269 @@
+import { EventEmitter } from 'events';
+import log from 'electron-log';
+import { 
+  AgentDefinition, 
+  AgentGuardrail, 
+  AgentExecutionContext, 
+  AgentHandler,
+  Agent,
+  AgentMessage 
+} from '../../shared/types';
+import { AIProviderManager } from '../providers/AIProviderManager';
+
+export class AgentSDK extends EventEmitter {
+  private handlers: Map<string, AgentHandler> = new Map();
+  private guardrails: AgentGuardrail[] = [];
+  private providerManager: AIProviderManager;
+  private agentDefinitions: Map<string, AgentDefinition> = new Map();
+
+  constructor(providerManager: AIProviderManager) {
+    super();
+    this.providerManager = providerManager;
+  }
+
+  // Register a custom agent definition
+  registerAgent(definition: AgentDefinition): void {
+    this.agentDefinitions.set(definition.id, definition);
+    this.emit('agent:registered', definition);
+    log.info(`Registered agent: ${definition.name} (${definition.id})`);
+  }
+
+  // Unregister an agent
+  unregisterAgent(agentId: string): boolean {
+    const deleted = this.agentDefinitions.delete(agentId);
+    if (deleted) {
+      this.emit('agent:unregistered', agentId);
+    }
+    return deleted;
+  }
+
+  // Get all registered agents
+  getAgents(): AgentDefinition[] {
+    return Array.from(this.agentDefinitions.values());
+  }
+
+  // Get agent by ID
+  getAgent(agentId: string): AgentDefinition | undefined {
+    return this.agentDefinitions.get(agentId);
+  }
+
+  // Register a custom handler (tool)
+  registerHandler(handler: AgentHandler): void {
+    this.handlers.set(handler.name, handler);
+    this.emit('handler:registered', handler);
+    log.info(`Registered handler: ${handler.name}`);
+  }
+
+  // Unregister a handler
+  unregisterHandler(name: string): boolean {
+    const deleted = this.handlers.delete(name);
+    if (deleted) {
+      this.emit('handler:unregistered', name);
+    }
+    return deleted;
+  }
+
+  // Get all handlers
+  getHandlers(): AgentHandler[] {
+    return Array.from(this.handlers.values());
+  }
+
+  // Add guardrail
+  addGuardrail(guardrail: AgentGuardrail): void {
+    this.guardrails.push(guardrail);
+    this.emit('guardrail:added', guardrail);
+    log.info(`Added guardrail: ${guardrail.type}`);
+  }
+
+  // Remove guardrail
+  removeGuardrail(type: string): boolean {
+    const index = this.guardrails.findIndex(g => g.type === type);
+    if (index > -1) {
+      const removed = this.guardrails.splice(index, 1)[0];
+      this.emit('guardrail:removed', removed);
+      return true;
+    }
+    return false;
+  }
+
+  // Execute agent with custom handler
+  async executeWithHandler(
+    agent: Agent,
+    handlerName: string,
+    params: Record<string, any>
+  ): Promise<any> {
+    const handler = this.handlers.get(handlerName);
+    if (!handler) {
+      throw new Error(`Handler not found: ${handlerName}`);
+    }
+
+    const context: AgentExecutionContext = {
+      agentId: agent.id,
+      sessionId: agent.id,
+      messages: agent.messages,
+      metadata: agent.metadata,
+    };
+
+    // Apply input guardrails
+    for (const guardrail of this.guardrails) {
+      if (guardrail.type === 'input_filter' && guardrail.enabled) {
+        const filtered = await this.applyGuardrail(guardrail, params);
+        params = filtered;
+      }
+    }
+
+    // Execute handler
+    const result = await handler.execute(context, params);
+
+    // Apply output guardrails
+    for (const guardrail of this.guardrails) {
+      if (guardrail.type === 'output_filter' && guardrail.enabled) {
+        const filtered = await this.applyGuardrail(guardrail, result);
+        return filtered;
+      }
+    }
+
+    return result;
+  }
+
+  private async applyGuardrail(guardrail: AgentGuardrail, data: any): Promise<any> {
+    switch (guardrail.type) {
+      case 'input_filter':
+        // Apply input filtering
+        return this.filterInput(data, guardrail.config);
+      case 'output_filter':
+        // Apply output filtering
+        return this.filterOutput(data, guardrail.config);
+      case 'tool_restriction':
+        // Check tool permissions
+        this.checkToolRestriction(data, guardrail.config);
+        return data;
+      default:
+        return data;
+    }
+  }
+
+  private filterInput(data: any, config: Record<string, any>): any {
+    // Simple input filtering - in production would be more sophisticated
+    const blockedPatterns = config.blockedPatterns || [];
+    
+    if (typeof data === 'string') {
+      for (const pattern of blockedPatterns) {
+        if (data.includes(pattern)) {
+          throw new Error(`Input blocked: contains "${pattern}"`);
+        }
+      }
+    }
+    
+    return data;
+  }
+
+  private filterOutput(data: any, config: Record<string, any>): any {
+    // Simple output filtering
+    const requiredPatterns = config.requiredPatterns || [];
+    const blockedPatterns = config.blockedPatterns || [];
+
+    if (typeof data === 'string') {
+      for (const pattern of blockedPatterns) {
+        if (data.includes(pattern)) {
+          data = data.replace(pattern, '[BLOCKED]');
+        }
+      }
+
+      if (requiredPatterns.length > 0) {
+        const hasRequired = requiredPatterns.some(p => data.includes(p));
+        if (!hasRequired) {
+          log.warn('Output does not contain required patterns');
+        }
+      }
+    }
+    
+    return data;
+  }
+
+  private checkToolRestriction(action: any, config: Record<string, any>): void {
+    const allowedTools = config.allowedTools;
+    const deniedTools = config.deniedTools || [];
+    const toolName = action.toolName || action.type;
+
+    if (allowedTools && !allowedTools.includes(toolName)) {
+      throw new Error(`Tool not allowed: ${toolName}`);
+    }
+
+    if (deniedTools.includes(toolName)) {
+      throw new Error(`Tool denied: ${toolName}`);
+    }
+  }
+
+  // Create agent from definition
+  async createAgentFromDefinition(
+    definitionId: string,
+    options: {
+      projectPath: string;
+      providerId?: string;
+      model?: string;
+    }
+  ): Promise<Partial<Agent>> {
+    const definition = this.agentDefinitions.get(definitionId);
+    if (!definition) {
+      throw new Error(`Agent definition not found: ${definitionId}`);
+    }
+
+    const agent: Partial<Agent> = {
+      id: `agent_${Date.now()}`,
+      name: definition.name,
+      projectPath: options.projectPath,
+      providerId: options.providerId || definition.provider || 'openai',
+      model: options.model || definition.model || 'gpt-4o',
+      skills: definition.skills || [],
+      messages: [],
+      tasks: [],
+      metadata: {
+        definitionId: definition.id,
+        version: definition.version,
+        author: definition.author,
+      },
+    };
+
+    // Add system prompt from definition
+    if (definition.systemPrompt) {
+      agent.messages = [{
+        id: `msg_${Date.now()}`,
+        role: 'system',
+        content: definition.systemPrompt,
+        timestamp: new Date(),
+      }];
+    }
+
+    this.emit('agent:created', agent);
+    return agent;
+  }
+
+  // Build system prompt from handlers
+  buildHandlerSystemPrompt(): string {
+    const parts: string[] = ['## Available Tools'];
+
+    for (const handler of this.handlers.values()) {
+      const paramsDesc = handler.parameters
+        ? Object.entries(handler.parameters)
+            .map(([key, val]) => `- ${key}: ${(val as any).type || 'any'}`)
+            .join('\n')
+        : 'No parameters';
+
+      parts.push(`### ${handler.name}`);
+      parts.push(handler.description);
+      parts.push(`Parameters:\n${paramsDesc}`);
+    }
+
+    return parts.join('\n\n');
+  }
+
+  cleanup(): void {
+    this.handlers.clear();
+    this.guardrails = [];
+    this.agentDefinitions.clear();
+    this.removeAllListeners();
+  }
+}
+
+export default AgentSDK;

package/src/main/agents/AgentTools.ts

@@ -0,0 +1,380 @@
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { spawn } from 'child_process';
+import log from 'electron-log';
+
+export interface ToolResult {
+  success: boolean;
+  output: string;
+  error?: string;
+}
+
+export interface ViewToolParams {
+  file_path: string;
+  offset?: number;
+  limit?: number;
+}
+
+export interface EditToolParams {
+  file_path: string;
+  old_string: string;
+  new_string: string;
+}
+
+export interface BashToolParams {
+  command: string;
+  timeout?: number;
+  cwd?: string;
+}
+
+export interface GlobToolParams {
+  pattern: string;
+  path?: string;
+}
+
+export interface GrepToolParams {
+  pattern: string;
+  path?: string;
+  include?: string;
+}
+
+export interface LsToolParams {
+  path: string;
+}
+
+export class AgentTools {
+  private worktreePath: string;
+
+  constructor(worktreePath: string) {
+    this.worktreePath = worktreePath;
+  }
+
+  private resolvePath(filePath: string): string {
+    const resolved = path.resolve(this.worktreePath, filePath);
+    const resolvedRoot = path.resolve(this.worktreePath);
+    if (!resolved.startsWith(resolvedRoot + path.sep) && resolved !== resolvedRoot) {
+      throw new Error('Path traversal detected: ' + filePath);
+    }
+    return resolved;
+  }
+
+  async view(params: ViewToolParams): Promise<ToolResult> {
+    try {
+      const fullPath = this.resolvePath(params.file_path);
+      const content = await fs.readFile(fullPath, 'utf-8');
+      const lines = content.split('\n');
+      
+      const offset = params.offset || 1;
+      const limit = params.limit || 200;
+      const startLine = Math.max(0, offset - 1);
+      const endLine = Math.min(lines.length, startLine + limit);
+      
+      const selectedLines = lines.slice(startLine, endLine);
+      const lineNumbers = selectedLines.map((_, idx) => startLine + idx + 1);
+      
+      const output = selectedLines
+        .map((line, idx) => `${lineNumbers[idx]}${' '.repeat(6 - String(lineNumbers[idx]).length)}|${line}`)
+        .join('\n');
+
+      return {
+        success: true,
+        output: output + (endLine < lines.length ? '\n... (truncated)' : '')
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: '',
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+
+  async edit(params: EditToolParams): Promise<ToolResult> {
+    try {
+      const fullPath = this.resolvePath(params.file_path);
+      const content = await fs.readFile(fullPath, 'utf-8');
+      
+      if (!content.includes(params.old_string)) {
+        return {
+          success: false,
+          output: '',
+          error: `String not found in file: "${params.old_string.slice(0, 50)}..."`
+        };
+      }
+
+      const occurrences = content.split(params.old_string).length - 1;
+      if (occurrences > 1) {
+        return {
+          success: false,
+          output: '',
+          error: `Multiple occurrences found (${occurrences}). Be more specific.`
+        };
+      }
+
+      const newContent = content.replace(params.old_string, params.new_string);
+      await fs.writeFile(fullPath, newContent, 'utf-8');
+
+      return {
+        success: true,
+        output: `File edited successfully: ${params.file_path}`
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: '',
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+
+  async bash(params: BashToolParams): Promise<ToolResult> {
+    return new Promise((resolve) => {
+      const cwd = params.cwd ? this.resolvePath(params.cwd) : this.worktreePath;
+      const timeout = params.timeout || 120000;
+      
+      const [cmd, ...args] = params.command.split(' ');
+      
+      const child = spawn(cmd, args, {
+        cwd,
+        shell: true,
+        env: { ...process.env, FORCE_COLOR: '1' }
+      });
+
+      let stdout = '';
+      let stderr = '';
+
+      child.stdout?.on('data', (data) => {
+        stdout += data.toString();
+      });
+
+      child.stderr?.on('data', (data) => {
+        stderr += data.toString();
+      });
+
+      const timeoutId = setTimeout(() => {
+        child.kill();
+        resolve({
+          success: false,
+          output: stdout,
+          error: `Command timed out after ${timeout}ms`
+        });
+      }, timeout);
+
+      child.on('close', (code) => {
+        clearTimeout(timeoutId);
+        resolve({
+          success: code === 0,
+          output: stdout || stderr,
+          error: code !== 0 ? `Exit code ${code}${stderr ? ': ' + stderr : ''}` : undefined
+        });
+      });
+
+      child.on('error', (error) => {
+        clearTimeout(timeoutId);
+        resolve({
+          success: false,
+          output: '',
+          error: error.message
+        });
+      });
+    });
+  }
+
+  async glob(params: GlobToolParams): Promise<ToolResult> {
+    try {
+      const searchPath = params.path ? this.resolvePath(params.path) : this.worktreePath;
+      const pattern = params.pattern;
+      
+      // Simple glob implementation using native fs
+      const files: string[] = [];
+      
+      async function walk(dir: string, relativeDir: string) {
+        const entries = await fs.readdir(dir, { withFileTypes: true });
+        
+        for (const entry of entries) {
+          const fullPath = path.join(dir, entry.name);
+          const relativePath = relativeDir ? path.join(relativeDir, entry.name) : entry.name;
+          
+          if (entry.isDirectory()) {
+            if (!entry.name.startsWith('.') && 
+                entry.name !== 'node_modules' && 
+                entry.name !== 'dist' && 
+                entry.name !== 'build') {
+              await walk(fullPath, relativePath);
+            }
+          } else if (entry.isFile()) {
+            // Simple pattern matching
+            if (pattern.includes('*')) {
+              const regex = new RegExp('^' + pattern.replace(/\*\*/g, '.*').replace(/\*/g, '[^/]*') + '$');
+              if (regex.test(relativePath)) {
+                files.push(relativePath);
+              }
+            } else if (relativePath.endsWith(pattern) || relativePath.includes(pattern)) {
+              files.push(relativePath);
+            }
+          }
+        }
+      }
+      
+      await walk(searchPath, '');
+
+      return {
+        success: true,
+        output: files.join('\n') || 'No files found'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: '',
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+
+  async grep(params: GrepToolParams): Promise<ToolResult> {
+    try {
+      const searchPath = params.path ? this.resolvePath(params.path) : this.worktreePath;
+      const { pattern, include } = params;
+      
+      const result = await this.bash({
+        command: `grep -r -n ${include ? `--include="${include}"` : ''} "${pattern}" .`,
+        cwd: searchPath
+      });
+
+      return result;
+    } catch (error) {
+      return {
+        success: false,
+        output: '',
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+
+  async ls(params: LsToolParams): Promise<ToolResult> {
+    try {
+      const fullPath = this.resolvePath(params.path);
+      const entries = await fs.readdir(fullPath, { withFileTypes: true });
+      
+      const output = entries
+        .map(entry => {
+          const type = entry.isDirectory() ? 'd' : entry.isFile() ? 'f' : '?';
+          return `${type} ${entry.name}`;
+        })
+        .join('\n');
+
+      return {
+        success: true,
+        output: output || '(empty directory)'
+      };
+    } catch (error) {
+      return {
+        success: false,
+        output: '',
+        error: error instanceof Error ? error.message : String(error)
+      };
+    }
+  }
+
+  getToolDefinitions(): Array<{ name: string; description: string; parameters: object }> {
+    return [
+      {
+        name: 'view',
+        description: 'View the contents of a file. Use offset and limit for large files.',
+        parameters: {
+          type: 'object',
+          properties: {
+            file_path: { type: 'string', description: 'Path to the file' },
+            offset: { type: 'number', description: 'Start line number (1-based)' },
+            limit: { type: 'number', description: 'Number of lines to show (max 200)' }
+          },
+          required: ['file_path']
+        }
+      },
+      {
+        name: 'edit',
+        description: 'Edit a file by replacing a specific string. The old_string must match exactly and uniquely.',
+        parameters: {
+          type: 'object',
+          properties: {
+            file_path: { type: 'string', description: 'Path to the file' },
+            old_string: { type: 'string', description: 'Exact string to replace' },
+            new_string: { type: 'string', description: 'Replacement string' }
+          },
+          required: ['file_path', 'old_string', 'new_string']
+        }
+      },
+      {
+        name: 'bash',
+        description: 'Execute a bash command in the worktree. Use for running tests, builds, git commands, etc.',
+        parameters: {
+          type: 'object',
+          properties: {
+            command: { type: 'string', description: 'Command to execute' },
+            timeout: { type: 'number', description: 'Timeout in milliseconds (default 120000)' }
+          },
+          required: ['command']
+        }
+      },
+      {
+        name: 'glob',
+        description: 'Find files matching a glob pattern (e.g., "**/*.ts").',
+        parameters: {
+          type: 'object',
+          properties: {
+            pattern: { type: 'string', description: 'Glob pattern' },
+            path: { type: 'string', description: 'Directory to search in' }
+          },
+          required: ['pattern']
+        }
+      },
+      {
+        name: 'grep',
+        description: 'Search for a pattern in file contents using grep.',
+        parameters: {
+          type: 'object',
+          properties: {
+            pattern: { type: 'string', description: 'Search pattern' },
+            path: { type: 'string', description: 'Directory to search in' },
+            include: { type: 'string', description: 'File pattern to include (e.g., "*.ts")' }
+          },
+          required: ['pattern']
+        }
+      },
+      {
+        name: 'ls',
+        description: 'List the contents of a directory.',
+        parameters: {
+          type: 'object',
+          properties: {
+            path: { type: 'string', description: 'Directory path' }
+          },
+          required: ['path']
+        }
+      }
+    ];
+  }
+
+  async executeTool(name: string, params: any): Promise<ToolResult> {
+    switch (name) {
+      case 'view':
+        return this.view(params);
+      case 'edit':
+        return this.edit(params);
+      case 'bash':
+        return this.bash(params);
+      case 'glob':
+        return this.glob(params);
+      case 'grep':
+        return this.grep(params);
+      case 'ls':
+        return this.ls(params);
+      default:
+        return {
+          success: false,
+          output: '',
+          error: `Unknown tool: ${name}`
+        };
+    }
+  }
+}