codex-linux 1.0.0

package/src/main/automations/AdvancedWebhookSystem.ts

@@ -0,0 +1,281 @@
+import { EventEmitter } from 'events';
+import axios from 'axios';
+import log from 'electron-log';
+
+interface WebhookTemplate {
+  id: string;
+  name: string;
+  description: string;
+  method: 'POST' | 'PUT' | 'PATCH';
+  headers: Record<string, string>;
+  payloadTemplate: string;
+}
+
+interface OutgoingWebhook {
+  id: string;
+  name: string;
+  url: string;
+  templateId: string;
+  events: string[];
+  enabled: boolean;
+  secret?: string;
+  retryCount: number;
+}
+
+interface WebhookPayload {
+  event: string;
+  timestamp: number;
+  data: any;
+  signature?: string;
+}
+
+export class AdvancedWebhookSystem extends EventEmitter {
+  private templates: Map<string, WebhookTemplate> = new Map();
+  private webhooks: Map<string, OutgoingWebhook> = new Map();
+  private retryAttempts: Map<string, number> = new Map();
+
+  constructor() {
+    super();
+    this.initializeDefaultTemplates();
+  }
+
+  private initializeDefaultTemplates(): void {
+    // Agent Event Template
+    this.templates.set('agent-event', {
+      id: 'agent-event',
+      name: 'Agent Event',
+      description: 'Standard template for agent events',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'User-Agent': 'Codex-Linux/1.0'
+      },
+      payloadTemplate: JSON.stringify({
+        event: '{{event}}',
+        timestamp: '{{timestamp}}',
+        agentId: '{{agentId}}',
+        data: '{{data}}'
+      }, null, 2)
+    });
+
+    // Task Completion Template
+    this.templates.set('task-completed', {
+      id: 'task-completed',
+      name: 'Task Completed',
+      description: 'Notifies when a task is completed',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      payloadTemplate: JSON.stringify({
+        event: 'task.completed',
+        timestamp: '{{timestamp}}',
+        agentId: '{{agentId}}',
+        taskId: '{{taskId}}',
+        result: '{{result}}',
+        duration: '{{duration}}'
+      }, null, 2)
+    });
+
+    // Error Notification Template
+    this.templates.set('error-alert', {
+      id: 'error-alert',
+      name: 'Error Alert',
+      description: 'Critical error notifications',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json',
+        'X-Priority': 'high'
+      },
+      payloadTemplate: JSON.stringify({
+        event: 'error',
+        timestamp: '{{timestamp}}',
+        severity: '{{severity}}',
+        component: '{{component}}',
+        message: '{{message}}',
+        stack: '{{stack}}'
+      }, null, 2)
+    });
+
+    // Automation Trigger Template
+    this.templates.set('automation-trigger', {
+      id: 'automation-trigger',
+      name: 'Automation Trigger',
+      description: 'Triggered when automation runs',
+      method: 'POST',
+      headers: {
+        'Content-Type': 'application/json'
+      },
+      payloadTemplate: JSON.stringify({
+        event: 'automation.executed',
+        timestamp: '{{timestamp}}',
+        automationId: '{{automationId}}',
+        automationName: '{{automationName}}',
+        trigger: '{{trigger}}',
+        status: '{{status}}'
+      }, null, 2)
+    });
+  }
+
+  createWebhook(
+    name: string,
+    url: string,
+    templateId: string,
+    events: string[],
+    options: {
+      secret?: string;
+      enabled?: boolean;
+    } = {}
+  ): string {
+    const webhookId = `webhook-${Date.now()}-${Math.random().toString(36).substr(2, 9)}`;
+
+    const webhook: OutgoingWebhook = {
+      id: webhookId,
+      name,
+      url,
+      templateId,
+      events,
+      enabled: options.enabled !== false,
+      secret: options.secret,
+      retryCount: 3
+    };
+
+    this.webhooks.set(webhookId, webhook);
+    log.info(`Created webhook: ${webhookId}`);
+    
+    this.emit('webhook:created', webhook);
+    return webhookId;
+  }
+
+  async triggerEvent(event: string, data: any): Promise<void> {
+    const webhooks = Array.from(this.webhooks.values()).filter(
+      w => w.enabled && w.events.includes(event)
+    );
+
+    await Promise.all(
+      webhooks.map(webhook => this.sendWebhook(webhook, event, data))
+    );
+  }
+
+  private async sendWebhook(
+    webhook: OutgoingWebhook,
+    event: string,
+    data: any
+  ): Promise<void> {
+    const template = this.templates.get(webhook.templateId);
+    if (!template) {
+      log.error(`Webhook template not found: ${webhook.templateId}`);
+      return;
+    }
+
+    const payload = this.buildPayload(template, event, data, webhook.secret);
+
+    try {
+      const response = await axios({
+        method: template.method,
+        url: webhook.url,
+        headers: template.headers,
+        data: payload,
+        timeout: 30000
+      });
+
+      log.debug(`Webhook sent: ${webhook.id}, Status: ${response.status}`);
+      this.emit('webhook:sent', { webhookId: webhook.id, event, status: response.status });
+      
+      // Clear retry count on success
+      this.retryAttempts.delete(webhook.id);
+    } catch (error) {
+      log.error(`Webhook failed: ${webhook.id}`, error);
+      
+      // Retry logic
+      const attempts = this.retryAttempts.get(webhook.id) || 0;
+      if (attempts < webhook.retryCount) {
+        this.retryAttempts.set(webhook.id, attempts + 1);
+        setTimeout(() => this.sendWebhook(webhook, event, data), 1000 * (attempts + 1));
+      } else {
+        this.emit('webhook:failed', { webhookId: webhook.id, event, error });
+        this.retryAttempts.delete(webhook.id);
+      }
+    }
+  }
+
+  private buildPayload(
+    template: WebhookTemplate,
+    event: string,
+    data: any,
+    secret?: string
+  ): any {
+    let payloadStr = template.payloadTemplate;
+
+    // Replace template variables
+    payloadStr = payloadStr.replace(/\{\{(\w+)\}\}/g, (match, key) => {
+      if (key === 'event') return event;
+      if (key === 'timestamp') return Date.now().toString();
+      if (data[key] !== undefined) return JSON.stringify(data[key]);
+      return match;
+    });
+
+    const payload = JSON.parse(payloadStr);
+
+    // Add signature if secret is provided
+    if (secret) {
+      payload.signature = this.generateSignature(payload, secret);
+    }
+
+    return payload;
+  }
+
+  private generateSignature(payload: any, secret: string): string {
+    // Simple HMAC-like signature (in production, use crypto library)
+    const crypto = require('crypto');
+    const data = JSON.stringify(payload);
+    return crypto
+      .createHmac('sha256', secret)
+      .update(data)
+      .digest('hex');
+  }
+
+  getTemplates(): WebhookTemplate[] {
+    return Array.from(this.templates.values());
+  }
+
+  getTemplate(templateId: string): WebhookTemplate | undefined {
+    return this.templates.get(templateId);
+  }
+
+  getWebhooks(): OutgoingWebhook[] {
+    return Array.from(this.webhooks.values());
+  }
+
+  getWebhook(webhookId: string): OutgoingWebhook | undefined {
+    return this.webhooks.get(webhookId);
+  }
+
+  updateWebhook(webhookId: string, updates: Partial<OutgoingWebhook>): void {
+    const webhook = this.webhooks.get(webhookId);
+    if (!webhook) throw new Error(`Webhook ${webhookId} not found`);
+
+    Object.assign(webhook, updates);
+    this.emit('webhook:updated', webhook);
+  }
+
+  deleteWebhook(webhookId: string): void {
+    this.webhooks.delete(webhookId);
+    this.emit('webhook:deleted', { webhookId });
+  }
+
+  createCustomTemplate(template: Omit<WebhookTemplate, 'id'>): string {
+    const id = `custom-${Date.now()}`;
+    this.templates.set(id, { ...template, id });
+    return id;
+  }
+
+  cleanup(): void {
+    this.webhooks.clear();
+    this.templates.clear();
+    this.retryAttempts.clear();
+    this.removeAllListeners();
+  }
+}
+
+export default AdvancedWebhookSystem;

package/src/main/automations/AutomationScheduler.ts

@@ -0,0 +1,272 @@
+import { EventEmitter } from 'events';
+import { v4 as uuidv4 } from 'uuid';
+import * as cron from 'node-cron';
+import * as fs from 'fs/promises';
+import * as path from 'path';
+import { app } from 'electron';
+import log from 'electron-log';
+import { exec } from 'child_process';
+import { promisify } from 'util';
+import { Automation, AutomationTrigger, AutomationAction, Agent } from '../../shared/types';
+import { NotificationManager } from '../notifications/NotificationManager';
+
+const execAsync = promisify(exec);
+
+const AUTOMATIONS_FILE = 'automations.json';
+
+export class AutomationScheduler extends EventEmitter {
+  private automations: Map<string, Automation> = new Map();
+  private scheduledTasks: Map<string, cron.ScheduledTask> = new Map();
+  private notificationManager?: NotificationManager;
+  private dataDir: string;
+
+  constructor() {
+    super();
+    this.dataDir = path.join(app.getPath('userData'), 'data');
+  }
+
+  setNotificationManager(notificationManager: NotificationManager): void {
+    this.notificationManager = notificationManager;
+  }
+
+  async initialize(): Promise<void> {
+    await this.loadAutomations();
+    log.info('Automation scheduler initialized');
+  }
+
+  private async loadAutomations(): Promise<void> {
+    try {
+      await fs.mkdir(this.dataDir, { recursive: true });
+      const filePath = path.join(this.dataDir, AUTOMATIONS_FILE);
+      const data = await fs.readFile(filePath, 'utf-8');
+      const automations: Automation[] = JSON.parse(data);
+      
+      for (const automation of automations) {
+        automation.createdAt = new Date(automation.createdAt);
+        automation.updatedAt = new Date(automation.updatedAt);
+        if (automation.lastRunAt) {
+          automation.lastRunAt = new Date(automation.lastRunAt);
+        }
+        this.automations.set(automation.id, automation);
+        
+        if (automation.enabled) {
+          await this.scheduleAutomation(automation);
+        }
+      }
+      log.info(`Loaded ${automations.length} automations`);
+    } catch (error: any) {
+      if (error.code !== 'ENOENT') {
+        log.error('Failed to load automations:', error);
+      }
+    }
+  }
+
+  private async saveAutomations(): Promise<void> {
+    try {
+      await fs.mkdir(this.dataDir, { recursive: true });
+      const filePath = path.join(this.dataDir, AUTOMATIONS_FILE);
+      const automations = Array.from(this.automations.values());
+      await fs.writeFile(filePath, JSON.stringify(automations, null, 2), 'utf-8');
+    } catch (error) {
+      log.error('Failed to save automations:', error);
+    }
+  }
+
+  async cleanup(): Promise<void> {
+    // Stop all scheduled tasks
+    for (const [id, task] of this.scheduledTasks) {
+      task.stop();
+    }
+    this.scheduledTasks.clear();
+  }
+
+  async listAutomations(): Promise<Automation[]> {
+    return Array.from(this.automations.values()).sort((a, b) =>
+      b.createdAt.getTime() - a.createdAt.getTime()
+    );
+  }
+
+  async createAutomation(config: Partial<Automation>): Promise<Automation> {
+    const automation: Automation = {
+      id: uuidv4(),
+      name: config.name || 'New Automation',
+      description: config.description || '',
+      enabled: config.enabled ?? false,
+      trigger: config.trigger || { type: 'manual', config: {} },
+      actions: config.actions || [],
+      createdAt: new Date(),
+      updatedAt: new Date(),
+      runCount: 0
+    };
+
+    this.automations.set(automation.id, automation);
+
+    if (automation.enabled) {
+      await this.scheduleAutomation(automation);
+    }
+
+    await this.saveAutomations();
+    this.emit('automation:created', automation);
+    log.info(`Created automation ${automation.id} (${automation.name})`);
+
+    return automation;
+  }
+
+  async updateAutomation(automationId: string, updates: Partial<Automation>): Promise<Automation> {
+    const automation = this.automations.get(automationId);
+    if (!automation) {
+      throw new Error(`Automation ${automationId} not found`);
+    }
+
+    // Stop existing schedule if any
+    await this.unscheduleAutomation(automationId);
+
+    Object.assign(automation, updates, { updatedAt: new Date() });
+
+    // Reschedule if enabled
+    if (automation.enabled) {
+      await this.scheduleAutomation(automation);
+    }
+
+    await this.saveAutomations();
+    this.emit('automation:updated', automation);
+    return automation;
+  }
+
+  async deleteAutomation(automationId: string): Promise<void> {
+    const automation = this.automations.get(automationId);
+    if (!automation) {
+      throw new Error(`Automation ${automationId} not found`);
+    }
+
+    await this.unscheduleAutomation(automationId);
+    this.automations.delete(automationId);
+
+    await this.saveAutomations();
+    this.emit('automation:deleted', { automationId });
+    log.info(`Deleted automation ${automationId}`);
+  }
+
+  async toggleAutomation(automationId: string, enabled: boolean): Promise<void> {
+    const automation = this.automations.get(automationId);
+    if (!automation) {
+      throw new Error(`Automation ${automationId} not found`);
+    }
+
+    automation.enabled = enabled;
+    automation.updatedAt = new Date();
+
+    if (enabled) {
+      await this.scheduleAutomation(automation);
+    } else {
+      await this.unscheduleAutomation(automationId);
+    }
+
+    this.emit('automation:toggled', { automationId, enabled });
+  }
+
+  async runAutomation(automationId: string): Promise<void> {
+    const automation = this.automations.get(automationId);
+    if (!automation) {
+      throw new Error(`Automation ${automationId} not found`);
+    }
+
+    log.info(`Running automation ${automationId} (${automation.name})`);
+    
+    automation.lastRunAt = new Date();
+    automation.runCount++;
+    automation.updatedAt = new Date();
+
+    try {
+      for (const action of automation.actions) {
+        await this.executeAction(action);
+      }
+
+      this.emit('automation:completed', { automationId, success: true });
+    } catch (error) {
+      log.error(`Automation ${automationId} failed:`, error);
+      this.emit('automation:completed', { automationId, success: false, error });
+    }
+  }
+
+  private async scheduleAutomation(automation: Automation): Promise<void> {
+    if (automation.trigger.type === 'schedule') {
+      const cronExpression = automation.trigger.config.cron;
+      
+      if (!cronExpression || !cron.validate(cronExpression)) {
+        log.error(`Invalid cron expression for automation ${automation.id}`);
+        return;
+      }
+
+      const task = cron.schedule(cronExpression, () => {
+        this.runAutomation(automation.id);
+      });
+
+      this.scheduledTasks.set(automation.id, task);
+      log.info(`Scheduled automation ${automation.id} with cron: ${cronExpression}`);
+    }
+  }
+
+  private async unscheduleAutomation(automationId: string): Promise<void> {
+    const task = this.scheduledTasks.get(automationId);
+    if (task) {
+      task.stop();
+      this.scheduledTasks.delete(automationId);
+      log.info(`Unscheduled automation ${automationId}`);
+    }
+  }
+
+  private async executeAction(action: AutomationAction): Promise<void> {
+    log.info(`Executing action: ${action.type}`, action.config);
+
+    switch (action.type) {
+      case 'createAgent':
+        this.emit('action:createAgent', action.config);
+        log.info(`Emitted createAgent event with config:`, action.config);
+        break;
+
+      case 'sendMessage':
+        this.emit('action:sendMessage', action.config);
+        log.info(`Emitted sendMessage event with config:`, action.config);
+        break;
+
+      case 'executeCommand': {
+        const { command, cwd = process.cwd() } = action.config;
+        if (!command) {
+          throw new Error('Command is required for executeCommand action');
+        }
+        try {
+          const { stdout, stderr } = await execAsync(command, { cwd });
+          log.info(`Command executed successfully: ${command}`, { stdout, stderr });
+          this.emit('action:executeCommand:result', { success: true, stdout, stderr });
+        } catch (error: any) {
+          log.error(`Command execution failed: ${command}`, error.message);
+          this.emit('action:executeCommand:result', { success: false, error: error.message });
+        }
+        break;
+      }
+
+      case 'runSkill':
+        this.emit('action:runSkill', action.config);
+        log.info(`Emitted runSkill event with config:`, action.config);
+        break;
+
+      case 'notify': {
+        const { title, body } = action.config;
+        if (!title || !body) {
+          throw new Error('Title and body are required for notify action');
+        }
+        if (this.notificationManager) {
+          this.notificationManager.show({ title, body });
+        } else {
+          this.emit('action:notify', { title, body });
+        }
+        log.info(`Notification shown: ${title}`);
+        break;
+      }
+
+      default:
+        log.warn(`Unknown action type: ${action.type}`);
+    }
+  }
+}