cowork-os 0.3.21

package/src/electron/agent/llm/types.ts

@@ -0,0 +1,291 @@
+/**
+ * LLM Provider abstraction types
+ * Allows switching between Anthropic API and AWS Bedrock
+ */
+
+export type LLMProviderType = 'anthropic' | 'bedrock' | 'ollama' | 'gemini' | 'openrouter' | 'openai';
+
+export interface LLMProviderConfig {
+  type: LLMProviderType;
+  model: string;
+  // Anthropic-specific
+  anthropicApiKey?: string;
+  // Bedrock-specific
+  awsRegion?: string;
+  awsAccessKeyId?: string;
+  awsSecretAccessKey?: string;
+  awsSessionToken?: string;
+  // Use AWS profile instead of explicit credentials
+  awsProfile?: string;
+  // Ollama-specific
+  ollamaBaseUrl?: string;
+  ollamaApiKey?: string; // Optional API key for remote Ollama servers
+  // Gemini-specific
+  geminiApiKey?: string;
+  // OpenRouter-specific
+  openrouterApiKey?: string;
+  // OpenAI-specific
+  openaiApiKey?: string;
+  openaiAccessToken?: string; // OAuth access token
+  openaiRefreshToken?: string; // OAuth refresh token
+  openaiTokenExpiresAt?: number; // OAuth token expiry timestamp
+}
+
+export interface LLMTool {
+  name: string;
+  description: string;
+  input_schema: {
+    type: 'object';
+    properties: Record<string, any>;
+    required?: string[];
+  };
+}
+
+export interface LLMToolUse {
+  type: 'tool_use';
+  id: string;
+  name: string;
+  input: Record<string, any>;
+}
+
+export interface LLMTextContent {
+  type: 'text';
+  text: string;
+}
+
+export type LLMContent = LLMToolUse | LLMTextContent;
+
+export interface LLMToolResult {
+  type: 'tool_result';
+  tool_use_id: string;
+  content: string;
+  is_error?: boolean;
+}
+
+export interface LLMMessage {
+  role: 'user' | 'assistant';
+  content: string | LLMContent[] | LLMToolResult[];
+}
+
+export interface LLMRequest {
+  model: string;
+  maxTokens: number;
+  system: string;
+  messages: LLMMessage[];
+  tools?: LLMTool[];
+  /** Optional abort signal to cancel the request */
+  signal?: AbortSignal;
+}
+
+export interface LLMResponse {
+  content: LLMContent[];
+  stopReason: 'end_turn' | 'tool_use' | 'max_tokens' | 'stop_sequence';
+  usage?: {
+    inputTokens: number;
+    outputTokens: number;
+  };
+}
+
+/**
+ * Abstract LLM Provider interface
+ */
+export interface LLMProvider {
+  readonly type: LLMProviderType;
+
+  /**
+   * Send a message to the LLM and get a response
+   */
+  createMessage(request: LLMRequest): Promise<LLMResponse>;
+
+  /**
+   * Test the provider connection
+   */
+  testConnection(): Promise<{ success: boolean; error?: string }>;
+}
+
+/**
+ * Available AI models with their IDs for each provider
+ * Note: Bedrock uses inference profile IDs (us. prefix) for newer models
+ * Note: Ollama models are dynamic and fetched from the server
+ */
+export const MODELS = {
+  'opus-4-5': {
+    anthropic: 'claude-opus-4-5-20251101',
+    bedrock: 'us.anthropic.claude-opus-4-5-20251101-v1:0',
+    displayName: 'Opus 4.5',
+  },
+  'sonnet-4-5': {
+    anthropic: 'claude-sonnet-4-5-20250514',
+    bedrock: 'us.anthropic.claude-sonnet-4-5-20250514-v1:0',
+    displayName: 'Sonnet 4.5',
+  },
+  'haiku-4-5': {
+    anthropic: 'claude-haiku-4-5-20250514',
+    bedrock: 'us.anthropic.claude-haiku-4-5-20250514-v1:0',
+    displayName: 'Haiku 4.5',
+  },
+  'sonnet-4': {
+    anthropic: 'claude-sonnet-4-20250514',
+    bedrock: 'us.anthropic.claude-sonnet-4-20250514-v1:0',
+    displayName: 'Sonnet 4',
+  },
+  'sonnet-3-5': {
+    anthropic: 'claude-3-5-sonnet-20241022',
+    bedrock: 'us.anthropic.claude-3-5-sonnet-20241022-v2:0',
+    displayName: 'Sonnet 3.5',
+  },
+  'haiku-3-5': {
+    anthropic: 'claude-3-5-haiku-20241022',
+    bedrock: 'us.anthropic.claude-3-5-haiku-20241022-v1:0',
+    displayName: 'Haiku 3.5',
+  },
+} as const;
+
+/**
+ * Available Gemini models from Google AI Studio
+ */
+export const GEMINI_MODELS = {
+  'gemini-2.5-pro': {
+    id: 'gemini-2.5-pro-preview-05-06',
+    displayName: 'Gemini 2.5 Pro',
+    description: 'Most capable model for complex tasks',
+  },
+  'gemini-2.5-flash': {
+    id: 'gemini-2.5-flash-preview-05-20',
+    displayName: 'Gemini 2.5 Flash',
+    description: 'Fast and efficient for most tasks',
+  },
+  'gemini-2.0-flash': {
+    id: 'gemini-2.0-flash',
+    displayName: 'Gemini 2.0 Flash',
+    description: 'Balanced speed and capability',
+  },
+  'gemini-2.0-flash-lite': {
+    id: 'gemini-2.0-flash-lite',
+    displayName: 'Gemini 2.0 Flash Lite',
+    description: 'Fastest and most cost-effective',
+  },
+  'gemini-1.5-pro': {
+    id: 'gemini-1.5-pro',
+    displayName: 'Gemini 1.5 Pro',
+    description: 'Previous generation pro model',
+  },
+  'gemini-1.5-flash': {
+    id: 'gemini-1.5-flash',
+    displayName: 'Gemini 1.5 Flash',
+    description: 'Previous generation flash model',
+  },
+} as const;
+
+export type GeminiModelKey = keyof typeof GEMINI_MODELS;
+
+/**
+ * Popular OpenRouter models
+ * OpenRouter provides access to many models from different providers
+ */
+export const OPENROUTER_MODELS = {
+  'anthropic/claude-3.5-sonnet': {
+    id: 'anthropic/claude-3.5-sonnet',
+    displayName: 'Claude 3.5 Sonnet',
+    description: 'Anthropic\'s balanced model',
+  },
+  'anthropic/claude-3-opus': {
+    id: 'anthropic/claude-3-opus',
+    displayName: 'Claude 3 Opus',
+    description: 'Anthropic\'s most capable model',
+  },
+  'openai/gpt-4o': {
+    id: 'openai/gpt-4o',
+    displayName: 'GPT-4o',
+    description: 'OpenAI\'s flagship model',
+  },
+  'openai/gpt-4o-mini': {
+    id: 'openai/gpt-4o-mini',
+    displayName: 'GPT-4o Mini',
+    description: 'OpenAI\'s fast and affordable model',
+  },
+  'google/gemini-pro-1.5': {
+    id: 'google/gemini-pro-1.5',
+    displayName: 'Gemini Pro 1.5',
+    description: 'Google\'s advanced model',
+  },
+  'meta-llama/llama-3.1-405b-instruct': {
+    id: 'meta-llama/llama-3.1-405b-instruct',
+    displayName: 'Llama 3.1 405B',
+    description: 'Meta\'s largest open model',
+  },
+  'mistralai/mistral-large': {
+    id: 'mistralai/mistral-large',
+    displayName: 'Mistral Large',
+    description: 'Mistral\'s flagship model',
+  },
+  'deepseek/deepseek-chat': {
+    id: 'deepseek/deepseek-chat',
+    displayName: 'DeepSeek Chat',
+    description: 'DeepSeek\'s conversational model',
+  },
+} as const;
+
+export type OpenRouterModelKey = keyof typeof OPENROUTER_MODELS;
+
+/**
+ * Available OpenAI models
+ * Users with ChatGPT Plus/Team/Enterprise subscriptions can use these models
+ */
+export const OPENAI_MODELS = {
+  'gpt-4o': {
+    id: 'gpt-4o',
+    displayName: 'GPT-4o',
+    description: 'Most capable model for complex tasks',
+  },
+  'gpt-4o-mini': {
+    id: 'gpt-4o-mini',
+    displayName: 'GPT-4o Mini',
+    description: 'Fast and affordable for most tasks',
+  },
+  'gpt-4-turbo': {
+    id: 'gpt-4-turbo',
+    displayName: 'GPT-4 Turbo',
+    description: 'Previous generation flagship',
+  },
+  'gpt-3.5-turbo': {
+    id: 'gpt-3.5-turbo',
+    displayName: 'GPT-3.5 Turbo',
+    description: 'Fast and cost-effective',
+  },
+  'o1': {
+    id: 'o1',
+    displayName: 'o1',
+    description: 'Advanced reasoning model',
+  },
+  'o1-mini': {
+    id: 'o1-mini',
+    displayName: 'o1 Mini',
+    description: 'Fast reasoning model',
+  },
+} as const;
+
+export type OpenAIModelKey = keyof typeof OPENAI_MODELS;
+
+/**
+ * Popular Ollama models with their details
+ * Users can use any model available on their Ollama server
+ */
+export const OLLAMA_MODELS = {
+  'llama3.2': { displayName: 'Llama 3.2', size: '3B' },
+  'llama3.1': { displayName: 'Llama 3.1', size: '8B' },
+  'llama3.1:70b': { displayName: 'Llama 3.1 70B', size: '70B' },
+  'mistral': { displayName: 'Mistral', size: '7B' },
+  'mixtral': { displayName: 'Mixtral', size: '47B' },
+  'codellama': { displayName: 'Code Llama', size: '7B' },
+  'deepseek-coder': { displayName: 'DeepSeek Coder', size: '6.7B' },
+  'qwen2.5': { displayName: 'Qwen 2.5', size: '7B' },
+  'phi3': { displayName: 'Phi-3', size: '3.8B' },
+  'gemma2': { displayName: 'Gemma 2', size: '9B' },
+} as const;
+
+export type OllamaModelKey = keyof typeof OLLAMA_MODELS;
+
+export type ModelKey = keyof typeof MODELS;
+
+export const DEFAULT_MODEL: ModelKey = 'opus-4-5';

package/src/electron/agent/queue-manager.ts

@@ -0,0 +1,408 @@
+/**
+ * Task Queue Manager
+ *
+ * Manages parallel task execution with configurable concurrency limits.
+ * Provides queue management, status tracking, and settings persistence.
+ * Settings are stored encrypted in the database using SecureSettingsRepository.
+ */
+
+import { app } from 'electron';
+import * as fs from 'fs';
+import * as path from 'path';
+import { Task, TaskStatus, QueueSettings, QueueStatus, DEFAULT_QUEUE_SETTINGS } from '../../shared/types';
+import { SecureSettingsRepository } from '../database/SecureSettingsRepository';
+
+const LEGACY_SETTINGS_FILE = 'queue-settings.json';
+
+// Forward declaration - will be set by daemon
+type DaemonCallbacks = {
+  startTaskImmediate: (task: Task) => Promise<void>;
+  emitQueueUpdate: (status: QueueStatus) => void;
+  getTaskById: (taskId: string) => Task | undefined;
+  updateTaskStatus: (taskId: string, status: TaskStatus) => void;
+  onTaskTimeout: (taskId: string) => Promise<void>;  // Called when a task times out
+};
+
+export class TaskQueueManager {
+  private queuedTaskIds: string[] = [];           // FIFO queue of task IDs
+  private runningTaskIds: Set<string> = new Set(); // Currently executing task IDs
+  private taskStartTimes: Map<string, number> = new Map(); // Track when each task started
+  private settings: QueueSettings;
+  private legacySettingsPath: string;
+  private callbacks: DaemonCallbacks;
+  private initialized: boolean = false;
+  private timeoutCheckInterval?: ReturnType<typeof setInterval>;
+  private static migrationCompleted = false;
+
+  constructor(callbacks: DaemonCallbacks) {
+    this.callbacks = callbacks;
+    const userDataPath = app.getPath('userData');
+    this.legacySettingsPath = path.join(userDataPath, LEGACY_SETTINGS_FILE);
+
+    // Migrate from legacy file if needed
+    this.migrateFromLegacyFile();
+
+    this.settings = this.loadSettings();
+
+    // Start periodic timeout check (every minute)
+    this.timeoutCheckInterval = setInterval(() => this.checkForTimedOutTasks(), 60 * 1000);
+  }
+
+  /**
+   * Migrate settings from legacy JSON file to encrypted database
+   */
+  private migrateFromLegacyFile(): void {
+    if (TaskQueueManager.migrationCompleted) return;
+
+    try {
+      if (!SecureSettingsRepository.isInitialized()) {
+        return;
+      }
+
+      const repository = SecureSettingsRepository.getInstance();
+
+      if (repository.exists('queue')) {
+        TaskQueueManager.migrationCompleted = true;
+        return;
+      }
+
+      if (!fs.existsSync(this.legacySettingsPath)) {
+        TaskQueueManager.migrationCompleted = true;
+        return;
+      }
+
+      console.log('[TaskQueueManager] Migrating settings from legacy JSON file to encrypted database...');
+
+      // Create backup before migration
+      const backupPath = this.legacySettingsPath + '.migration-backup';
+      fs.copyFileSync(this.legacySettingsPath, backupPath);
+
+      try {
+        const data = fs.readFileSync(this.legacySettingsPath, 'utf-8');
+        const parsed = JSON.parse(data);
+        const merged = { ...DEFAULT_QUEUE_SETTINGS, ...parsed };
+
+        repository.save('queue', merged);
+        console.log('[TaskQueueManager] Settings migrated to encrypted database');
+
+        // Migration successful - delete backup and original
+        fs.unlinkSync(backupPath);
+        fs.unlinkSync(this.legacySettingsPath);
+        console.log('[TaskQueueManager] Migration complete, cleaned up legacy files');
+
+        TaskQueueManager.migrationCompleted = true;
+      } catch (migrationError) {
+        console.error('[TaskQueueManager] Migration failed, backup preserved at:', backupPath);
+        throw migrationError;
+      }
+    } catch (error) {
+      console.error('[TaskQueueManager] Migration failed:', error);
+    }
+  }
+
+  /**
+   * Cleanup resources (call on shutdown)
+   */
+  destroy(): void {
+    if (this.timeoutCheckInterval) {
+      clearInterval(this.timeoutCheckInterval);
+      this.timeoutCheckInterval = undefined;
+    }
+  }
+
+  /**
+   * Initialize the queue manager - recover queue from database on startup
+   * Should be called after database is ready
+   */
+  async initialize(
+    queuedTasks: Task[],
+    runningTasks: Task[]
+  ): Promise<void> {
+    if (this.initialized) {
+      console.log('[TaskQueueManager] Already initialized, skipping');
+      return;
+    }
+
+    console.log('[TaskQueueManager] Initializing queue manager');
+    console.log(`[TaskQueueManager] Found ${queuedTasks.length} queued tasks, ${runningTasks.length} running tasks`);
+
+    // Restore queued tasks in FIFO order by creation time
+    this.queuedTaskIds = queuedTasks
+      .sort((a, b) => a.createdAt - b.createdAt)
+      .map(t => t.id);
+
+    // Track currently running tasks
+    runningTasks.forEach(t => this.runningTaskIds.add(t.id));
+
+    this.initialized = true;
+
+    // Start processing queue if there are slots available
+    await this.processQueue();
+
+    // Emit initial queue status
+    this.emitQueueUpdate();
+  }
+
+  /**
+   * Enqueue a new task - either start immediately or add to queue
+   *
+   * Sub-agents (tasks with parentTaskId) bypass the concurrency limit to prevent
+   * deadlocks where a parent task waits for sub-agents that are stuck in the queue.
+   */
+  async enqueue(task: Task): Promise<void> {
+    console.log(`[TaskQueueManager] Enqueueing task ${task.id}: ${task.title}`);
+
+    // Sub-agents bypass concurrency limits to prevent deadlock
+    // (parent would wait forever for sub-agents stuck in queue)
+    const isSubAgent = !!task.parentTaskId;
+
+    if (isSubAgent) {
+      console.log(`[TaskQueueManager] Starting sub-agent immediately (bypasses concurrency limit)`);
+      await this.startTask(task);
+    } else if (this.canStartImmediately()) {
+      console.log(`[TaskQueueManager] Starting task immediately (${this.runningTaskIds.size}/${this.settings.maxConcurrentTasks} slots used)`);
+      await this.startTask(task);
+    } else {
+      console.log(`[TaskQueueManager] Queue full, adding task to queue (position: ${this.queuedTaskIds.length + 1})`);
+      this.queuedTaskIds.push(task.id);
+      this.callbacks.updateTaskStatus(task.id, 'queued');
+      this.emitQueueUpdate();
+    }
+  }
+
+  /**
+   * Called when a task finishes (completed, failed, or cancelled)
+   */
+  async onTaskFinished(taskId: string): Promise<void> {
+    console.log(`[TaskQueueManager] Task ${taskId} finished`);
+
+    // Remove from running set and clear start time
+    this.runningTaskIds.delete(taskId);
+    this.taskStartTimes.delete(taskId);
+
+    // Process next task in queue
+    await this.processQueue();
+
+    // Emit updated status
+    this.emitQueueUpdate();
+  }
+
+  /**
+   * Cancel a queued task (remove from queue without starting)
+   * Returns true if task was in queue and removed
+   */
+  cancelQueuedTask(taskId: string): boolean {
+    const index = this.queuedTaskIds.indexOf(taskId);
+    if (index !== -1) {
+      console.log(`[TaskQueueManager] Removing task ${taskId} from queue`);
+      this.queuedTaskIds.splice(index, 1);
+      this.emitQueueUpdate();
+      return true;
+    }
+    return false;
+  }
+
+  /**
+   * Check if a task is currently in the queue
+   */
+  isQueued(taskId: string): boolean {
+    return this.queuedTaskIds.includes(taskId);
+  }
+
+  /**
+   * Check if a task is currently running
+   */
+  isRunning(taskId: string): boolean {
+    return this.runningTaskIds.has(taskId);
+  }
+
+  /**
+   * Clear all stuck tasks from the running set
+   * This should be used to recover from stuck state when tasks fail to clean up
+   * Returns the number of tasks cleared
+   */
+  clearStuckTasks(): { clearedRunning: number; clearedQueued: number } {
+    const clearedRunning = this.runningTaskIds.size;
+    const clearedQueued = this.queuedTaskIds.length;
+
+    console.log(`[TaskQueueManager] Clearing ${clearedRunning} running tasks and ${clearedQueued} queued tasks`);
+
+    // Clear running tasks and their start times
+    this.runningTaskIds.clear();
+    this.taskStartTimes.clear();
+
+    // Clear queued tasks
+    this.queuedTaskIds = [];
+
+    // Emit update
+    this.emitQueueUpdate();
+
+    return { clearedRunning, clearedQueued };
+  }
+
+  /**
+   * Get current queue status for UI
+   */
+  getStatus(): QueueStatus {
+    return {
+      runningCount: this.runningTaskIds.size,
+      queuedCount: this.queuedTaskIds.length,
+      runningTaskIds: Array.from(this.runningTaskIds),
+      queuedTaskIds: [...this.queuedTaskIds],
+      maxConcurrent: this.settings.maxConcurrentTasks,
+    };
+  }
+
+  /**
+   * Get current settings
+   */
+  getSettings(): QueueSettings {
+    return { ...this.settings };
+  }
+
+  /**
+   * Update settings
+   */
+  saveSettings(newSettings: Partial<QueueSettings>): void {
+    // Validate maxConcurrentTasks
+    if (newSettings.maxConcurrentTasks !== undefined) {
+      newSettings.maxConcurrentTasks = Math.max(1, Math.min(10, newSettings.maxConcurrentTasks));
+    }
+
+    // Validate taskTimeoutMinutes (5 min to 4 hours)
+    if (newSettings.taskTimeoutMinutes !== undefined) {
+      newSettings.taskTimeoutMinutes = Math.max(5, Math.min(240, newSettings.taskTimeoutMinutes));
+    }
+
+    this.settings = { ...this.settings, ...newSettings };
+
+    try {
+      if (SecureSettingsRepository.isInitialized()) {
+        const repository = SecureSettingsRepository.getInstance();
+        repository.save('queue', this.settings);
+        console.log('[TaskQueueManager] Settings saved to encrypted database');
+      } else {
+        console.warn('[TaskQueueManager] SecureSettingsRepository not initialized, settings not persisted');
+      }
+    } catch (error) {
+      console.error('[TaskQueueManager] Failed to save settings:', error);
+    }
+
+    // Process queue in case we increased concurrency
+    this.processQueue();
+    this.emitQueueUpdate();
+  }
+
+  // ===== Private Methods =====
+
+  /**
+   * Process the queue - start tasks if slots are available
+   */
+  private async processQueue(): Promise<void> {
+    while (this.canStartImmediately() && this.queuedTaskIds.length > 0) {
+      const nextTaskId = this.queuedTaskIds.shift()!;
+      const task = this.callbacks.getTaskById(nextTaskId);
+
+      if (task && task.status === 'queued') {
+        console.log(`[TaskQueueManager] Dequeuing task ${nextTaskId}`);
+        await this.startTask(task);
+      } else {
+        console.log(`[TaskQueueManager] Skipping task ${nextTaskId} (not found or status changed)`);
+      }
+    }
+  }
+
+  /**
+   * Check if we can start a task immediately
+   */
+  private canStartImmediately(): boolean {
+    return this.runningTaskIds.size < this.settings.maxConcurrentTasks;
+  }
+
+  /**
+   * Start a task
+   */
+  private async startTask(task: Task): Promise<void> {
+    this.runningTaskIds.add(task.id);
+    this.taskStartTimes.set(task.id, Date.now());
+    this.emitQueueUpdate();
+
+    try {
+      await this.callbacks.startTaskImmediate(task);
+    } catch (error) {
+      console.error(`[TaskQueueManager] Failed to start task ${task.id}:`, error);
+      this.runningTaskIds.delete(task.id);
+      this.taskStartTimes.delete(task.id);
+      this.emitQueueUpdate();
+    }
+  }
+
+  /**
+   * Emit queue status update
+   */
+  private emitQueueUpdate(): void {
+    this.callbacks.emitQueueUpdate(this.getStatus());
+  }
+
+  /**
+   * Check for tasks that have exceeded the timeout and clear them
+   */
+  private async checkForTimedOutTasks(): Promise<void> {
+    const now = Date.now();
+    const timeoutMs = this.settings.taskTimeoutMinutes * 60 * 1000;
+    const timedOutTasks: string[] = [];
+
+    // Find tasks that have exceeded the timeout
+    for (const [taskId, startTime] of this.taskStartTimes) {
+      const elapsed = now - startTime;
+      if (elapsed > timeoutMs) {
+        const elapsedMinutes = Math.round(elapsed / 60000);
+        console.log(`[TaskQueueManager] Task ${taskId} has timed out (running for ${elapsedMinutes} minutes, timeout: ${this.settings.taskTimeoutMinutes} minutes)`);
+        timedOutTasks.push(taskId);
+      }
+    }
+
+    // Process timed out tasks
+    for (const taskId of timedOutTasks) {
+      try {
+        // Notify daemon to handle the timeout (cancel task, cleanup resources)
+        await this.callbacks.onTaskTimeout(taskId);
+
+        // Remove from tracking (daemon will call onTaskFinished which also removes, but do it here just in case)
+        this.runningTaskIds.delete(taskId);
+        this.taskStartTimes.delete(taskId);
+      } catch (error) {
+        console.error(`[TaskQueueManager] Error handling timeout for task ${taskId}:`, error);
+        // Force remove from tracking even if daemon callback fails
+        this.runningTaskIds.delete(taskId);
+        this.taskStartTimes.delete(taskId);
+      }
+    }
+
+    // If any tasks were cleared, process the queue and emit update
+    if (timedOutTasks.length > 0) {
+      await this.processQueue();
+      this.emitQueueUpdate();
+    }
+  }
+
+  /**
+   * Load settings from encrypted database
+   */
+  private loadSettings(): QueueSettings {
+    try {
+      if (SecureSettingsRepository.isInitialized()) {
+        const repository = SecureSettingsRepository.getInstance();
+        const stored = repository.load<QueueSettings>('queue');
+        if (stored) {
+          // Merge with defaults to handle missing fields
+          console.log('[TaskQueueManager] Loaded settings from encrypted database');
+          return { ...DEFAULT_QUEUE_SETTINGS, ...stored };
+        }
+      }
+    } catch (error) {
+      console.error('[TaskQueueManager] Failed to load settings:', error);
+    }
+    return { ...DEFAULT_QUEUE_SETTINGS };
+  }
+}