codex-linux 1.0.0

package/src/main/automations/GitLabCIManager.ts

@@ -0,0 +1,206 @@
+import { EventEmitter } from 'events';
+import log from 'electron-log';
+import fetch, { RequestInit } from 'node-fetch';
+
+export interface GitLabCIConfig {
+  url: string;
+  token: string;
+  projectId: string;
+  defaultBranch: string;
+}
+
+export interface GitLabPipeline {
+  id: number;
+  status: 'created' | 'waiting_for_resource' | 'preparing' | 'pending' | 'running' | 'success' | 'failed' | 'canceled' | 'skipped' | 'manual' | 'scheduled';
+  ref: string;
+  sha: string;
+  webUrl: string;
+  createdAt: string;
+  updatedAt: string;
+}
+
+export interface GitLabJob {
+  id: number;
+  name: string;
+  status: string;
+  stage: string;
+  pipeline: { id: number };
+  webUrl: string;
+  artifacts?: { size: number };
+}
+
+export class GitLabCIManager extends EventEmitter {
+  private config: GitLabCIConfig | null = null;
+
+  constructor() {
+    super();
+  }
+
+  async configure(config: GitLabCIConfig): Promise<void> {
+    this.config = config;
+    log.info('GitLab CI configured', { project: config.projectId, url: config.url });
+  }
+
+  private getApiUrl(): string {
+    if (!this.config) throw new Error('GitLab CI not configured');
+    return `${this.config.url}/api/v4`;
+  }
+
+  private async request(endpoint: string, method: string = 'GET', body?: string): Promise<any> {
+    if (!this.config) throw new Error('GitLab CI not configured');
+
+    const options: RequestInit = {
+      method,
+      headers: {
+        'PRIVATE-TOKEN': this.config.token,
+        'Content-Type': 'application/json',
+      },
+    };
+
+    if (body) {
+      options.body = body;
+    }
+
+    const response = await fetch(`${this.getApiUrl()}${endpoint}`, options);
+
+    if (!response.ok) {
+      const error = await response.text();
+      throw new Error(`GitLab API error: ${response.status} - ${error}`);
+    }
+
+    return response.json();
+  }
+
+  async listPipelines(options?: {
+    ref?: string;
+    status?: string;
+    orderBy?: 'id' | 'updated_at';
+    perPage?: number;
+  }): Promise<GitLabPipeline[]> {
+    const params = new URLSearchParams();
+    if (options?.ref) params.append('ref', options.ref);
+    if (options?.status) params.append('status', options.status);
+    if (options?.orderBy) params.append('order_by', options.orderBy);
+    if (options?.perPage) params.append('per_page', String(options.perPage));
+
+    return this.request(`/projects/${encodeURIComponent(this.config!.projectId)}/pipelines?${params}`) as Promise<GitLabPipeline[]>;
+  }
+
+  async getPipeline(pipelineId: number): Promise<GitLabPipeline> {
+    return this.request(`/projects/${encodeURIComponent(this.config!.projectId)}/pipelines/${pipelineId}`) as Promise<GitLabPipeline>;
+  }
+
+  async triggerPipeline(options: {
+    ref: string;
+    variables?: Record<string, string>;
+  }): Promise<GitLabPipeline> {
+    if (!this.config) throw new Error('GitLab CI not configured');
+
+    const body = JSON.stringify({
+      ref: options.ref,
+      variables: options.variables
+        ? Object.entries(options.variables).map(([key, value]) => ({ key, value }))
+        : undefined,
+    });
+
+    return this.request(
+      `/projects/${encodeURIComponent(this.config.projectId)}/pipeline`,
+      'POST',
+      body
+    ) as Promise<GitLabPipeline>;
+  }
+
+  async cancelPipeline(pipelineId: number): Promise<GitLabPipeline> {
+    return this.request(
+      `/projects/${encodeURIComponent(this.config!.projectId)}/pipelines/${pipelineId}/cancel`,
+      'POST'
+    ) as Promise<GitLabPipeline>;
+  }
+
+  async retryPipeline(pipelineId: number): Promise<GitLabPipeline> {
+    return this.request(
+      `/projects/${encodeURIComponent(this.config!.projectId)}/pipelines/${pipelineId}/retry`,
+      'POST'
+    ) as Promise<GitLabPipeline>;
+  }
+
+  async getPipelineJobs(pipelineId: number): Promise<GitLabJob[]> {
+    return this.request(
+      `/projects/${encodeURIComponent(this.config!.projectId)}/pipelines/${pipelineId}/jobs`
+    ) as Promise<GitLabJob[]>;
+  }
+
+  async getJobTrace(jobId: number): Promise<string> {
+    if (!this.config) throw new Error('GitLab CI not configured');
+
+    const response = await fetch(
+      `${this.getApiUrl()}/projects/${encodeURIComponent(this.config.projectId)}/jobs/${jobId}/trace`,
+      {
+        headers: {
+          'PRIVATE-TOKEN': this.config.token,
+        },
+      }
+    );
+
+    if (!response.ok) {
+      throw new Error(`Failed to get job trace: ${response.statusText}`);
+    }
+
+    return response.text();
+  }
+
+  async playJob(jobId: number): Promise<GitLabJob> {
+    return this.request(
+      `/projects/${encodeURIComponent(this.config!.projectId)}/jobs/${jobId}/play`,
+      'POST'
+    ) as Promise<GitLabJob>;
+  }
+
+  async cancelJob(jobId: number): Promise<GitLabJob> {
+    return this.request(
+      `/projects/${encodeURIComponent(this.config!.projectId)}/jobs/${jobId}/cancel`,
+      'POST'
+    ) as Promise<GitLabJob>;
+  }
+
+  async listMergeRequestPipelines(mrIid: number): Promise<GitLabPipeline[]> {
+    return this.request(
+      `/projects/${encodeURIComponent(this.config!.projectId)}/merge_requests/${mrIid}/pipelines`
+    ) as Promise<GitLabPipeline[]>;
+  }
+
+  async getPipelineVariables(pipelineId: number): Promise<Array<{ key: string; value: string }>> {
+    return this.request(
+      `/projects/${encodeURIComponent(this.config!.projectId)}/pipelines/${pipelineId}/variables`
+    ) as Promise<Array<{ key: string; value: string }>>;
+  }
+
+  async createPipelineSchedule(options: {
+    ref: string;
+    description: string;
+    cron?: string;
+  }): Promise<any> {
+    const body = JSON.stringify({
+      description: options.description,
+      ref: options.ref,
+      cron: options.cron,
+    });
+
+    return this.request(
+      `/projects/${encodeURIComponent(this.config!.projectId)}/pipeline_schedules`,
+      'POST',
+      body
+    );
+  }
+
+  getConfig(): GitLabCIConfig | null {
+    return this.config ? { ...this.config } : null;
+  }
+
+  cleanup(): void {
+    this.config = null;
+    this.removeAllListeners();
+  }
+}
+
+export default GitLabCIManager;

package/src/main/automations/PriorityQueueManager.ts

@@ -0,0 +1,328 @@
+import { EventEmitter } from 'events';
+import { v4 as uuidv4 } from 'uuid';
+import log from 'electron-log';
+
+export type PriorityLevel = 'critical' | 'high' | 'normal' | 'low' | 'background';
+
+export type PriorityEntityType = 'task' | 'agent' | 'message' | 'request';
+
+export interface PriorityItem {
+  id: string;
+  type: PriorityEntityType;
+  priority: PriorityLevel;
+  score: number;
+  data: unknown;
+  createdAt: Date;
+  scheduledAt?: Date;
+  deadline?: Date;
+  metadata: Record<string, unknown>;
+}
+
+export interface PriorityConfig {
+  defaultPriority: PriorityLevel;
+  maxQueueSize: number;
+  enableDeadline: boolean;
+  priorityBoost: number;
+}
+
+export interface QueueStats {
+  totalItems: number;
+  byPriority: Record<PriorityLevel, number>;
+  averageWaitTime: number;
+  processedCount: number;
+}
+
+export class PriorityQueueManager extends EventEmitter {
+  private queue: PriorityItem[] = [];
+  private config: PriorityConfig;
+  private processedCount = 0;
+  private startTimes: Map<string, number> = new Map();
+
+  constructor(config?: Partial<PriorityConfig>) {
+    super();
+    this.config = {
+      defaultPriority: config?.defaultPriority || 'normal',
+      maxQueueSize: config?.maxQueueSize || 1000,
+      enableDeadline: config?.enableDeadline ?? true,
+      priorityBoost: config?.priorityBoost || 10,
+    };
+  }
+
+  configure(config: Partial<PriorityConfig>): void {
+    this.config = { ...this.config, ...config };
+    log.info('PriorityQueueManager configured', this.config);
+  }
+
+  getConfig(): PriorityConfig {
+    return { ...this.config };
+  }
+
+  private calculateScore(item: PriorityItem): number {
+    const priorityScores: Record<PriorityLevel, number> = {
+      critical: 100,
+      high: 75,
+      normal: 50,
+      low: 25,
+      background: 10,
+    };
+
+    let score = priorityScores[item.priority] || 50;
+
+    if (item.deadline && this.config.enableDeadline) {
+      const timeUntilDeadline = item.deadline.getTime() - Date.now();
+      if (timeUntilDeadline < 0) {
+        score += 50;
+      } else if (timeUntilDeadline < 3600000) {
+        score += Math.floor(1000000 / timeUntilDeadline);
+      }
+    }
+
+    if (item.scheduledAt) {
+      const waitTime = item.scheduledAt.getTime() - Date.now();
+      if (waitTime < 0) {
+        score += Math.min(20, Math.floor(-waitTime / 60000));
+      }
+    }
+
+    const age = Date.now() - item.createdAt.getTime();
+    score += Math.min(10, Math.floor(age / 300000));
+
+    return score;
+  }
+
+  private reindex(): void {
+    this.queue.forEach((item) => {
+      item.score = this.calculateScore(item);
+    });
+    this.queue.sort((a, b) => b.score - a.score);
+  }
+
+  enqueue(
+    type: PriorityEntityType,
+    data: unknown,
+    options: {
+      priority?: PriorityLevel;
+      deadline?: Date;
+      scheduledAt?: Date;
+      metadata?: Record<string, unknown>;
+    } = {}
+  ): PriorityItem {
+    if (this.queue.length >= this.config.maxQueueSize) {
+      this.evictLowest();
+    }
+
+    const item: PriorityItem = {
+      id: uuidv4(),
+      type,
+      priority: options.priority || this.config.defaultPriority,
+      score: 0,
+      data,
+      createdAt: new Date(),
+      deadline: options.deadline,
+      scheduledAt: options.scheduledAt,
+      metadata: options.metadata || {},
+    };
+
+    item.score = this.calculateScore(item);
+    this.queue.push(item);
+    this.startTimes.set(item.id, Date.now());
+    this.reindex();
+
+    this.emit('item:enqueued', item);
+    log.debug(`Item enqueued: ${type} with priority ${item.priority}`);
+
+    return item;
+  }
+
+  dequeue(): PriorityItem | null {
+    const now = new Date();
+    
+    const readyItems = this.queue.filter(
+      (item) => !item.scheduledAt || item.scheduledAt <= now
+    );
+
+    if (readyItems.length === 0) return null;
+
+    const item = readyItems[0];
+    this.queue = this.queue.filter((i) => i.id !== item.id);
+    this.startTimes.delete(item.id);
+    this.processedCount++;
+
+    this.emit('item:dequeued', item);
+    log.debug(`Item dequeued: ${item.type} with score ${item.score}`);
+
+    return item;
+  }
+
+  peek(): PriorityItem | null {
+    const now = new Date();
+    const readyItems = this.queue.filter(
+      (item) => !item.scheduledAt || item.scheduledAt <= now
+    );
+    return readyItems.length > 0 ? readyItems[0] : null;
+  }
+
+  get(id: string): PriorityItem | undefined {
+    return this.queue.find((item) => item.id === id);
+  }
+
+  updatePriority(id: string, priority: PriorityLevel): boolean {
+    const item = this.queue.find((i) => i.id === id);
+    if (!item) return false;
+
+    item.priority = priority;
+    item.score = this.calculateScore(item);
+    this.reindex();
+
+    this.emit('priority:updated', item);
+    log.debug(`Priority updated for ${id}: ${priority}`);
+    return true;
+  }
+
+  boostPriority(id: string, boost: number = 1): boolean {
+    const item = this.queue.find((i) => i.id === id);
+    if (!item) return false;
+
+    const priorityScores: Record<PriorityLevel, number> = {
+      critical: 100,
+      high: 75,
+      normal: 50,
+      low: 25,
+      background: 10,
+    };
+
+    const currentIndex = Object.keys(priorityScores).indexOf(item.priority);
+    const newIndex = Math.max(0, currentIndex - boost);
+    const newPriority = Object.keys(priorityScores)[newIndex] as PriorityLevel;
+    
+    item.priority = newPriority;
+    item.score = this.calculateScore(item);
+    this.reindex();
+
+    this.emit('priority:boosted', item);
+    return true;
+  }
+
+  reschedule(id: string, scheduledAt: Date): boolean {
+    const item = this.queue.find((i) => i.id === id);
+    if (!item) return false;
+
+    item.scheduledAt = scheduledAt;
+    item.score = this.calculateScore(item);
+    this.reindex();
+
+    this.emit('item:rescheduled', item);
+    return true;
+  }
+
+  setDeadline(id: string, deadline: Date): boolean {
+    const item = this.queue.find((i) => i.id === id);
+    if (!item) return false;
+
+    item.deadline = deadline;
+    item.score = this.calculateScore(item);
+    this.reindex();
+
+    this.emit('deadline:set', item);
+    return true;
+  }
+
+  remove(id: string): boolean {
+    const index = this.queue.findIndex((i) => i.id === id);
+    if (index === -1) return false;
+
+    const item = this.queue[index];
+    this.queue.splice(index, 1);
+    this.startTimes.delete(id);
+
+    this.emit('item:removed', item);
+    return true;
+  }
+
+  cancel(predicate: (item: PriorityItem) => boolean): number {
+    const toRemove = this.queue.filter(predicate);
+    toRemove.forEach((item) => {
+      this.queue = this.queue.filter((i) => i.id !== item.id);
+      this.startTimes.delete(item.id);
+      this.emit('item:cancelled', item);
+    });
+    return toRemove.length;
+  }
+
+  private evictLowest(): void {
+    if (this.queue.length === 0) return;
+
+    const lowest = this.queue[this.queue.length - 1];
+    this.queue.pop();
+    this.startTimes.delete(lowest.id);
+    this.emit('item:evicted', lowest);
+    log.debug(`Evicted lowest priority item: ${lowest.id}`);
+  }
+
+  getQueue(filter?: {
+    type?: PriorityEntityType;
+    priority?: PriorityLevel;
+    scheduled?: boolean;
+  }): PriorityItem[] {
+    let items = [...this.queue];
+
+    if (filter?.type) {
+      items = items.filter((i) => i.type === filter.type);
+    }
+    if (filter?.priority) {
+      items = items.filter((i) => i.priority === filter.priority);
+    }
+    if (filter?.scheduled !== undefined) {
+      items = items.filter((i) =>
+        filter.scheduled ? !!i.scheduledAt : !i.scheduledAt
+      );
+    }
+
+    return items;
+  }
+
+  getStats(): QueueStats {
+    const byPriority: Record<PriorityLevel, number> = {
+      critical: 0,
+      high: 0,
+      normal: 0,
+      low: 0,
+      background: 0,
+    };
+
+    let totalWaitTime = 0;
+
+    this.queue.forEach((item) => {
+      byPriority[item.priority]++;
+      const startTime = this.startTimes.get(item.id);
+      if (startTime) {
+        totalWaitTime += Date.now() - startTime;
+      }
+    });
+
+    return {
+      totalItems: this.queue.length,
+      byPriority,
+      averageWaitTime:
+        this.queue.length > 0 ? totalWaitTime / this.queue.length : 0,
+      processedCount: this.processedCount,
+    };
+  }
+
+  clear(): void {
+    const count = this.queue.length;
+    this.queue = [];
+    this.startTimes.clear();
+    this.emit('queue:cleared', { count });
+    log.info(`Cleared ${count} items from priority queue`);
+  }
+
+  cleanup(): void {
+    this.queue = [];
+    this.startTimes.clear();
+    this.removeAllListeners();
+    log.info('PriorityQueueManager cleaned up');
+  }
+}
+
+export default PriorityQueueManager;

package/src/main/background/BackgroundModeManager.ts

@@ -0,0 +1,130 @@
+import { EventEmitter } from 'events';
+import { app, Tray, Menu } from 'electron';
+import log from 'electron-log';
+
+export class BackgroundModeManager extends EventEmitter {
+  private tray: Tray | null = null;
+  private isRunning: boolean = false;
+  private backgroundAgents: Set<string> = new Set();
+
+  constructor() {
+    super();
+  }
+
+  async enable(): Promise<void> {
+    if (this.isRunning) return;
+
+    this.isRunning = true;
+    this.setupTray();
+    
+    log.info('Background mode enabled');
+    this.emit('enabled');
+  }
+
+  disable(): void {
+    if (!this.isRunning) return;
+
+    this.isRunning = false;
+    
+    if (this.tray) {
+      this.tray.destroy();
+      this.tray = null;
+    }
+
+    log.info('Background mode disabled');
+    this.emit('disabled');
+  }
+
+  private setupTray(): void {
+    // Create tray icon (would need actual icon path)
+    // this.tray = new Tray(path.join(__dirname, 'assets/tray-icon.png'));
+    
+    if (!this.tray) return;
+
+    const contextMenu = Menu.buildFromTemplate([
+      {
+        label: 'Show App',
+        click: () => {
+          this.emit('show-app');
+        }
+      },
+      {
+        label: 'Background Agents',
+        submenu: [
+          {
+            label: `Active: ${this.backgroundAgents.size}`,
+            enabled: false
+          },
+          { type: 'separator' },
+          {
+            label: 'View All',
+            click: () => {
+              this.emit('view-agents');
+            }
+          }
+        ]
+      },
+      { type: 'separator' },
+      {
+        label: 'Disable Background Mode',
+        click: () => {
+          this.disable();
+        }
+      },
+      { type: 'separator' },
+      {
+        label: 'Quit',
+        click: () => {
+          app.quit();
+        }
+      }
+    ]);
+
+    this.tray.setToolTip('Codex Linux - Running in background');
+    this.tray.setContextMenu(contextMenu);
+
+    this.tray.on('click', () => {
+      this.emit('show-app');
+    });
+  }
+
+  registerBackgroundAgent(agentId: string): void {
+    this.backgroundAgents.add(agentId);
+    this.emit('agent:registered', agentId);
+    log.debug(`Background agent registered: ${agentId}`);
+  }
+
+  unregisterBackgroundAgent(agentId: string): void {
+    this.backgroundAgents.delete(agentId);
+    this.emit('agent:unregistered', agentId);
+    log.debug(`Background agent unregistered: ${agentId}`);
+  }
+
+  showNotification(title: string, body: string): void {
+    if (!this.tray) return;
+
+    // On Linux, tray can show balloon notifications
+    // this.tray.displayBalloon({ iconType: 'info', title, content: body });
+    
+    // Or use native notifications
+    // new Notification({ title, body }).show();
+  }
+
+  getStatus(): {
+    enabled: boolean;
+    backgroundAgents: number;
+  } {
+    return {
+      enabled: this.isRunning,
+      backgroundAgents: this.backgroundAgents.size
+    };
+  }
+
+  cleanup(): void {
+    this.disable();
+    this.backgroundAgents.clear();
+    this.removeAllListeners();
+  }
+}
+
+export default BackgroundModeManager;