cowork-os 0.3.21

package/dist/electron/electron/agent/llm/types.js

@@ -0,0 +1,178 @@
+"use strict";
+/**
+ * LLM Provider abstraction types
+ * Allows switching between Anthropic API and AWS Bedrock
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_MODEL = exports.OLLAMA_MODELS = exports.OPENAI_MODELS = exports.OPENROUTER_MODELS = exports.GEMINI_MODELS = exports.MODELS = void 0;
+/**
+ * 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
+ */
+exports.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',
+    },
+};
+/**
+ * Available Gemini models from Google AI Studio
+ */
+exports.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',
+    },
+};
+/**
+ * Popular OpenRouter models
+ * OpenRouter provides access to many models from different providers
+ */
+exports.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',
+    },
+};
+/**
+ * Available OpenAI models
+ * Users with ChatGPT Plus/Team/Enterprise subscriptions can use these models
+ */
+exports.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',
+    },
+};
+/**
+ * Popular Ollama models with their details
+ * Users can use any model available on their Ollama server
+ */
+exports.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' },
+};
+exports.DEFAULT_MODEL = 'opus-4-5';

package/dist/electron/electron/agent/queue-manager.js

@@ -0,0 +1,378 @@
+"use strict";
+/**
+ * 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.
+ */
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TaskQueueManager = void 0;
+const electron_1 = require("electron");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const types_1 = require("../../shared/types");
+const SecureSettingsRepository_1 = require("../database/SecureSettingsRepository");
+const LEGACY_SETTINGS_FILE = 'queue-settings.json';
+class TaskQueueManager {
+    constructor(callbacks) {
+        this.queuedTaskIds = []; // FIFO queue of task IDs
+        this.runningTaskIds = new Set(); // Currently executing task IDs
+        this.taskStartTimes = new Map(); // Track when each task started
+        this.initialized = false;
+        this.callbacks = callbacks;
+        const userDataPath = electron_1.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
+     */
+    migrateFromLegacyFile() {
+        if (TaskQueueManager.migrationCompleted)
+            return;
+        try {
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                return;
+            }
+            const repository = SecureSettingsRepository_1.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 = { ...types_1.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() {
+        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, runningTasks) {
+        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) {
+        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) {
+        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) {
+        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) {
+        return this.queuedTaskIds.includes(taskId);
+    }
+    /**
+     * Check if a task is currently running
+     */
+    isRunning(taskId) {
+        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() {
+        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() {
+        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() {
+        return { ...this.settings };
+    }
+    /**
+     * Update settings
+     */
+    saveSettings(newSettings) {
+        // 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_1.SecureSettingsRepository.isInitialized()) {
+                const repository = SecureSettingsRepository_1.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
+     */
+    async processQueue() {
+        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
+     */
+    canStartImmediately() {
+        return this.runningTaskIds.size < this.settings.maxConcurrentTasks;
+    }
+    /**
+     * Start a task
+     */
+    async startTask(task) {
+        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
+     */
+    emitQueueUpdate() {
+        this.callbacks.emitQueueUpdate(this.getStatus());
+    }
+    /**
+     * Check for tasks that have exceeded the timeout and clear them
+     */
+    async checkForTimedOutTasks() {
+        const now = Date.now();
+        const timeoutMs = this.settings.taskTimeoutMinutes * 60 * 1000;
+        const timedOutTasks = [];
+        // 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
+     */
+    loadSettings() {
+        try {
+            if (SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+                const stored = repository.load('queue');
+                if (stored) {
+                    // Merge with defaults to handle missing fields
+                    console.log('[TaskQueueManager] Loaded settings from encrypted database');
+                    return { ...types_1.DEFAULT_QUEUE_SETTINGS, ...stored };
+                }
+            }
+        }
+        catch (error) {
+            console.error('[TaskQueueManager] Failed to load settings:', error);
+        }
+        return { ...types_1.DEFAULT_QUEUE_SETTINGS };
+    }
+}
+exports.TaskQueueManager = TaskQueueManager;
+TaskQueueManager.migrationCompleted = false;