cowork-os 0.3.21

package/dist/electron/electron/memory/MemoryService.js

@@ -0,0 +1,435 @@
+"use strict";
+/**
+ * Memory Service
+ *
+ * Core service for the persistent memory system.
+ * Handles capture, compression, search, and context injection.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.MemoryService = void 0;
+const events_1 = require("events");
+const repositories_1 = require("../database/repositories");
+const llm_1 = require("../agent/llm");
+const context_manager_1 = require("../agent/context-manager");
+const security_1 = require("../agent/security");
+// Privacy patterns to exclude - matches common sensitive data patterns
+const SENSITIVE_PATTERNS = [
+    /api[_-]?key/i,
+    /secret/i,
+    /password/i,
+    /passwd/i,
+    /token/i,
+    /credential/i,
+    /auth/i,
+    /bearer\s+[a-zA-Z0-9\-_]+/i,
+    /ssh[_-]?key/i,
+    /private[_-]?key/i,
+    /\.env/i,
+    /aws[_-]?access/i,
+    /aws[_-]?secret/i,
+    /-----BEGIN\s+(RSA\s+)?PRIVATE\s+KEY-----/i,
+    /ghp_[a-zA-Z0-9]+/i, // GitHub personal access token
+    /gho_[a-zA-Z0-9]+/i, // GitHub OAuth token
+    /sk-[a-zA-Z0-9]+/i, // OpenAI API key format
+    /xox[baprs]-[a-zA-Z0-9-]+/i, // Slack tokens
+];
+// Events for reactive updates
+const memoryEvents = new events_1.EventEmitter();
+// Minimum tokens before compression is worthwhile
+const MIN_TOKENS_FOR_COMPRESSION = 100;
+// Compression batch size
+const COMPRESSION_BATCH_SIZE = 10;
+// Cleanup interval (1 hour)
+const CLEANUP_INTERVAL_MS = 60 * 60 * 1000;
+// Compression delay between items (avoid rate limits)
+const COMPRESSION_DELAY_MS = 200;
+class MemoryService {
+    /**
+     * Initialize the memory service
+     */
+    static initialize(dbManager) {
+        if (this.initialized)
+            return;
+        const db = dbManager.getDatabase();
+        this.memoryRepo = new repositories_1.MemoryRepository(db);
+        this.summaryRepo = new repositories_1.MemorySummaryRepository(db);
+        this.settingsRepo = new repositories_1.MemorySettingsRepository(db);
+        this.initialized = true;
+        // Start periodic cleanup
+        this.cleanupIntervalHandle = setInterval(() => this.runCleanup(), CLEANUP_INTERVAL_MS);
+        console.log('[MemoryService] Initialized');
+    }
+    /**
+     * Subscribe to memory events
+     */
+    static onMemoryChanged(callback) {
+        memoryEvents.on('memoryChanged', callback);
+        return () => memoryEvents.off('memoryChanged', callback);
+    }
+    /**
+     * Capture an observation from task execution
+     */
+    static async capture(workspaceId, taskId, type, content, isPrivate = false) {
+        this.ensureInitialized();
+        // Check settings
+        const settings = this.settingsRepo.getOrCreate(workspaceId);
+        if (!settings.enabled || !settings.autoCapture) {
+            return null;
+        }
+        // Check privacy mode
+        if (settings.privacyMode === 'disabled') {
+            return null;
+        }
+        // Check excluded patterns
+        if (this.shouldExclude(content, settings)) {
+            return null;
+        }
+        // Check for sensitive content
+        const containsSensitive = this.containsSensitiveData(content);
+        const finalIsPrivate = isPrivate || containsSensitive || settings.privacyMode === 'strict';
+        // Estimate tokens
+        const tokens = (0, context_manager_1.estimateTokens)(content);
+        // Truncate very long content
+        const truncatedContent = content.length > 10000 ? content.slice(0, 10000) + '\n[... truncated]' : content;
+        // Create memory
+        const memory = this.memoryRepo.create({
+            workspaceId,
+            taskId,
+            type,
+            content: truncatedContent,
+            tokens,
+            isCompressed: false,
+            isPrivate: finalIsPrivate,
+        });
+        // Queue for compression if enabled and large enough
+        if (settings.compressionEnabled && tokens > MIN_TOKENS_FOR_COMPRESSION && !finalIsPrivate) {
+            this.compressionQueue.push(memory.id);
+            this.processCompressionQueue();
+        }
+        // Emit event
+        memoryEvents.emit('memoryChanged', { type: 'created', workspaceId });
+        return memory;
+    }
+    /**
+     * Search memories - Layer 1 of progressive retrieval
+     * Returns IDs + brief snippets (~50 tokens each)
+     */
+    static search(workspaceId, query, limit = 20) {
+        this.ensureInitialized();
+        return this.memoryRepo.search(workspaceId, query, limit);
+    }
+    /**
+     * Get timeline context - Layer 2 of progressive retrieval
+     * Returns surrounding memories for context
+     */
+    static getTimelineContext(memoryId, windowSize = 5) {
+        this.ensureInitialized();
+        return this.memoryRepo.getTimelineContext(memoryId, windowSize);
+    }
+    /**
+     * Get full details - Layer 3 of progressive retrieval
+     * Only called for specific memories when needed
+     */
+    static getFullDetails(ids) {
+        this.ensureInitialized();
+        return this.memoryRepo.getFullDetails(ids);
+    }
+    /**
+     * Get memories for a specific task
+     */
+    static getByTask(taskId) {
+        this.ensureInitialized();
+        return this.memoryRepo.findByTask(taskId);
+    }
+    /**
+     * Get recent memories for a workspace
+     */
+    static getRecent(workspaceId, limit = 20) {
+        this.ensureInitialized();
+        return this.memoryRepo.getRecentForWorkspace(workspaceId, limit);
+    }
+    /**
+     * Get context for injection at task start
+     * Returns a formatted string suitable for system prompt
+     */
+    static getContextForInjection(workspaceId, taskPrompt) {
+        this.ensureInitialized();
+        const settings = this.settingsRepo.getOrCreate(workspaceId);
+        if (!settings.enabled) {
+            return '';
+        }
+        // Get recent memories (summaries preferred)
+        const recentMemories = this.memoryRepo.getRecentForWorkspace(workspaceId, 5);
+        // Search for relevant memories based on task prompt
+        let relevantMemories = [];
+        if (taskPrompt && taskPrompt.length > 10) {
+            try {
+                // Extract key terms for search
+                const searchTerms = this.extractSearchTerms(taskPrompt);
+                if (searchTerms) {
+                    relevantMemories = this.memoryRepo.search(workspaceId, searchTerms, 5);
+                    // Filter out memories that are already in recent
+                    const recentIds = new Set(recentMemories.map((m) => m.id));
+                    relevantMemories = relevantMemories.filter((m) => !recentIds.has(m.id));
+                }
+            }
+            catch {
+                // Search failed, continue without relevant memories
+            }
+        }
+        if (recentMemories.length === 0 && relevantMemories.length === 0) {
+            return '';
+        }
+        const parts = ['<memory_context>'];
+        parts.push('The following memories from previous sessions may be relevant:');
+        // Add recent memories (summaries only for token efficiency)
+        if (recentMemories.length > 0) {
+            parts.push('\n## Recent Activity');
+            for (const memory of recentMemories) {
+                const rawText = memory.summary || this.truncate(memory.content, 150);
+                // Sanitize memory content to prevent injection via stored memories
+                const text = security_1.InputSanitizer.sanitizeMemoryContent(rawText);
+                const date = new Date(memory.createdAt).toLocaleDateString();
+                parts.push(`- [${memory.type}] (${date}) ${text}`);
+            }
+        }
+        // Add relevant memories
+        if (relevantMemories.length > 0) {
+            parts.push('\n## Relevant to Current Task');
+            for (const result of relevantMemories) {
+                const date = new Date(result.createdAt).toLocaleDateString();
+                // Sanitize memory content to prevent injection via stored memories
+                const sanitizedSnippet = security_1.InputSanitizer.sanitizeMemoryContent(result.snippet);
+                parts.push(`- [${result.type}] (${date}) ${sanitizedSnippet}`);
+            }
+        }
+        parts.push('</memory_context>');
+        return parts.join('\n');
+    }
+    /**
+     * Get or create settings for a workspace
+     */
+    static getSettings(workspaceId) {
+        this.ensureInitialized();
+        return this.settingsRepo.getOrCreate(workspaceId);
+    }
+    /**
+     * Update settings for a workspace
+     */
+    static updateSettings(workspaceId, updates) {
+        this.ensureInitialized();
+        this.settingsRepo.update(workspaceId, updates);
+        memoryEvents.emit('memoryChanged', { type: 'settingsUpdated', workspaceId });
+    }
+    /**
+     * Get storage statistics for a workspace
+     */
+    static getStats(workspaceId) {
+        this.ensureInitialized();
+        return this.memoryRepo.getStats(workspaceId);
+    }
+    /**
+     * Delete all memories for a workspace
+     */
+    static clearWorkspace(workspaceId) {
+        this.ensureInitialized();
+        this.memoryRepo.deleteByWorkspace(workspaceId);
+        this.summaryRepo.deleteByWorkspace(workspaceId);
+        memoryEvents.emit('memoryChanged', { type: 'cleared', workspaceId });
+    }
+    /**
+     * Process compression queue asynchronously
+     */
+    static async processCompressionQueue() {
+        if (this.compressionInProgress || this.compressionQueue.length === 0) {
+            return;
+        }
+        this.compressionInProgress = true;
+        try {
+            // Process in batches
+            const batch = this.compressionQueue.splice(0, COMPRESSION_BATCH_SIZE);
+            for (const memoryId of batch) {
+                await this.compressMemory(memoryId);
+                // Small delay to avoid overwhelming the LLM
+                await new Promise((resolve) => setTimeout(resolve, COMPRESSION_DELAY_MS));
+            }
+            // Continue if more items
+            if (this.compressionQueue.length > 0) {
+                setTimeout(() => this.processCompressionQueue(), 1000);
+            }
+        }
+        catch (error) {
+            console.error('[MemoryService] Compression queue error:', error);
+        }
+        finally {
+            this.compressionInProgress = false;
+        }
+    }
+    /**
+     * Compress a single memory using LLM
+     */
+    static async compressMemory(memoryId) {
+        const memory = this.memoryRepo.findById(memoryId);
+        if (!memory || memory.isCompressed || memory.summary)
+            return;
+        try {
+            // Get LLM provider for compression
+            const provider = llm_1.LLMProviderFactory.createProvider();
+            const settings = llm_1.LLMProviderFactory.getSettings();
+            const modelId = llm_1.LLMProviderFactory.getModelId(settings.modelKey, settings.providerType, settings.ollama?.model, settings.gemini?.model, settings.openrouter?.model, settings.openai?.model);
+            const response = await provider.createMessage({
+                model: modelId,
+                maxTokens: 100,
+                system: 'You are a helpful assistant that summarizes text concisely.',
+                messages: [
+                    {
+                        role: 'user',
+                        content: `Summarize this observation in 1-2 sentences (max 50 words). Focus on the key insight, decision, or action taken. Be concise and factual.
+
+Observation:
+${memory.content}
+
+Summary:`,
+                    },
+                ],
+            });
+            // Extract summary from response
+            let summary = '';
+            for (const content of response.content) {
+                if (content.type === 'text') {
+                    summary += content.text;
+                }
+            }
+            summary = summary.trim();
+            if (summary) {
+                const summaryTokens = (0, context_manager_1.estimateTokens)(summary);
+                this.memoryRepo.update(memoryId, {
+                    summary,
+                    tokens: summaryTokens,
+                    isCompressed: true,
+                });
+            }
+        }
+        catch (error) {
+            // Log but don't fail - compression is optional enhancement
+            console.warn('[MemoryService] Compression failed for memory:', memoryId, error);
+        }
+    }
+    /**
+     * Run periodic cleanup based on retention policies
+     */
+    static async runCleanup() {
+        if (!this.initialized)
+            return;
+        try {
+            // Get all workspaces with memories
+            const workspacesWithMemories = new Set();
+            // Find unique workspace IDs from recent memories
+            const recentMemories = this.memoryRepo.getUncompressed(1000);
+            for (const memory of recentMemories) {
+                workspacesWithMemories.add(memory.workspaceId);
+            }
+            // Process each workspace
+            for (const workspaceId of workspacesWithMemories) {
+                const settings = this.settingsRepo.getOrCreate(workspaceId);
+                const retentionMs = settings.retentionDays * 24 * 60 * 60 * 1000;
+                const cutoff = Date.now() - retentionMs;
+                const deleted = this.memoryRepo.deleteOlderThan(workspaceId, cutoff);
+                if (deleted > 0) {
+                    console.log(`[MemoryService] Cleaned up ${deleted} old memories for workspace ${workspaceId}`);
+                }
+            }
+        }
+        catch (error) {
+            console.error('[MemoryService] Cleanup failed:', error);
+        }
+    }
+    /**
+     * Extract search terms from task prompt
+     */
+    static extractSearchTerms(prompt) {
+        // Remove common words and extract meaningful terms
+        const stopWords = new Set([
+            'a', 'an', 'the', 'is', 'are', 'was', 'were', 'be', 'been', 'being',
+            'have', 'has', 'had', 'do', 'does', 'did', 'will', 'would', 'could',
+            'should', 'may', 'might', 'can', 'must', 'shall', 'to', 'of', 'in',
+            'for', 'on', 'with', 'at', 'by', 'from', 'up', 'about', 'into',
+            'over', 'after', 'beneath', 'under', 'above', 'and', 'or', 'but',
+            'if', 'then', 'else', 'when', 'where', 'why', 'how', 'all', 'each',
+            'every', 'both', 'few', 'more', 'most', 'other', 'some', 'such',
+            'no', 'nor', 'not', 'only', 'own', 'same', 'so', 'than', 'too',
+            'very', 'just', 'also', 'now', 'please', 'help', 'me', 'i', 'my',
+            'want', 'need', 'like', 'make', 'create', 'add', 'update', 'fix',
+        ]);
+        const words = prompt
+            .toLowerCase()
+            .replace(/[^\w\s]/g, ' ')
+            .split(/\s+/)
+            .filter((word) => word.length > 2 && !stopWords.has(word));
+        // Take first 5 meaningful words for search
+        return words.slice(0, 5).join(' OR ');
+    }
+    /**
+     * Check if content should be excluded
+     */
+    static shouldExclude(content, settings) {
+        if (!settings.excludedPatterns || settings.excludedPatterns.length === 0) {
+            return false;
+        }
+        for (const pattern of settings.excludedPatterns) {
+            try {
+                const regex = new RegExp(pattern, 'i');
+                if (regex.test(content)) {
+                    return true;
+                }
+            }
+            catch {
+                // Invalid regex pattern, skip
+            }
+        }
+        return false;
+    }
+    /**
+     * Check if content contains sensitive data
+     */
+    static containsSensitiveData(content) {
+        for (const pattern of SENSITIVE_PATTERNS) {
+            if (pattern.test(content)) {
+                return true;
+            }
+        }
+        return false;
+    }
+    /**
+     * Truncate text to specified length
+     */
+    static truncate(text, maxLength) {
+        if (text.length <= maxLength)
+            return text;
+        return text.slice(0, maxLength - 3) + '...';
+    }
+    /**
+     * Ensure service is initialized
+     */
+    static ensureInitialized() {
+        if (!this.initialized) {
+            throw new Error('[MemoryService] Not initialized. Call MemoryService.initialize() first.');
+        }
+    }
+    /**
+     * Shutdown the service
+     */
+    static shutdown() {
+        if (this.cleanupIntervalHandle) {
+            clearInterval(this.cleanupIntervalHandle);
+            this.cleanupIntervalHandle = undefined;
+        }
+        memoryEvents.removeAllListeners();
+        this.initialized = false;
+        console.log('[MemoryService] Shutdown complete');
+    }
+}
+exports.MemoryService = MemoryService;
+MemoryService.initialized = false;
+MemoryService.compressionQueue = [];
+MemoryService.compressionInProgress = false;

package/dist/electron/electron/notifications/index.js

@@ -0,0 +1,17 @@
+"use strict";
+/**
+ * Notification module exports
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_NOTIFICATION_DIR = exports.DEFAULT_NOTIFICATION_STORE_PATH = exports.getNotificationDir = exports.getNotificationStorePath = exports.saveNotificationStoreSync = exports.saveNotificationStore = exports.loadNotificationStoreSync = exports.loadNotificationStore = exports.NotificationService = void 0;
+var service_1 = require("./service");
+Object.defineProperty(exports, "NotificationService", { enumerable: true, get: function () { return service_1.NotificationService; } });
+var store_1 = require("./store");
+Object.defineProperty(exports, "loadNotificationStore", { enumerable: true, get: function () { return store_1.loadNotificationStore; } });
+Object.defineProperty(exports, "loadNotificationStoreSync", { enumerable: true, get: function () { return store_1.loadNotificationStoreSync; } });
+Object.defineProperty(exports, "saveNotificationStore", { enumerable: true, get: function () { return store_1.saveNotificationStore; } });
+Object.defineProperty(exports, "saveNotificationStoreSync", { enumerable: true, get: function () { return store_1.saveNotificationStoreSync; } });
+Object.defineProperty(exports, "getNotificationStorePath", { enumerable: true, get: function () { return store_1.getNotificationStorePath; } });
+Object.defineProperty(exports, "getNotificationDir", { enumerable: true, get: function () { return store_1.getNotificationDir; } });
+Object.defineProperty(exports, "DEFAULT_NOTIFICATION_STORE_PATH", { enumerable: true, get: function () { return store_1.DEFAULT_NOTIFICATION_STORE_PATH; } });
+Object.defineProperty(exports, "DEFAULT_NOTIFICATION_DIR", { enumerable: true, get: function () { return store_1.DEFAULT_NOTIFICATION_DIR; } });

package/dist/electron/electron/notifications/service.js

@@ -0,0 +1,118 @@
+"use strict";
+/**
+ * Notification Service - Manages in-app notifications
+ * Provides CRUD operations and emits events for UI updates
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.NotificationService = void 0;
+const node_crypto_1 = require("node:crypto");
+const store_1 = require("./store");
+class NotificationService {
+    constructor(config = {}) {
+        this.notifications = [];
+        this.storePath = config.storePath || (0, store_1.getNotificationStorePath)();
+        this.onEvent = config.onEvent;
+        // Load notifications synchronously on startup
+        const store = (0, store_1.loadNotificationStoreSync)(this.storePath);
+        this.notifications = store.notifications;
+        console.log(`[Notifications] Loaded ${this.notifications.length} notifications from store`);
+    }
+    /**
+     * Get all notifications (sorted by date, newest first)
+     */
+    list() {
+        return [...this.notifications].sort((a, b) => b.createdAt - a.createdAt);
+    }
+    /**
+     * Get unread count
+     */
+    getUnreadCount() {
+        return this.notifications.filter((n) => !n.read).length;
+    }
+    /**
+     * Add a new notification
+     */
+    async add(params) {
+        const notification = {
+            id: (0, node_crypto_1.randomUUID)(),
+            type: params.type,
+            title: params.title,
+            message: params.message,
+            read: false,
+            createdAt: Date.now(),
+            taskId: params.taskId,
+            cronJobId: params.cronJobId,
+            workspaceId: params.workspaceId,
+        };
+        this.notifications.unshift(notification);
+        await this.save();
+        this.emit({ type: 'added', notification });
+        return notification;
+    }
+    /**
+     * Mark a notification as read
+     */
+    async markRead(id) {
+        const notification = this.notifications.find((n) => n.id === id);
+        if (!notification)
+            return null;
+        notification.read = true;
+        await this.save();
+        this.emit({ type: 'updated', notification });
+        return notification;
+    }
+    /**
+     * Mark all notifications as read
+     */
+    async markAllRead() {
+        const unread = this.notifications.filter((n) => !n.read);
+        if (unread.length === 0)
+            return;
+        for (const n of unread) {
+            n.read = true;
+        }
+        await this.save();
+        this.emit({ type: 'updated', notifications: this.notifications });
+    }
+    /**
+     * Delete a notification
+     */
+    async delete(id) {
+        const index = this.notifications.findIndex((n) => n.id === id);
+        if (index === -1)
+            return false;
+        const [removed] = this.notifications.splice(index, 1);
+        await this.save();
+        this.emit({ type: 'removed', notification: removed });
+        return true;
+    }
+    /**
+     * Delete all notifications
+     */
+    async deleteAll() {
+        if (this.notifications.length === 0)
+            return;
+        this.notifications = [];
+        await this.save();
+        this.emit({ type: 'cleared' });
+    }
+    /**
+     * Save notifications to disk
+     */
+    async save() {
+        const store = {
+            version: 1,
+            notifications: this.notifications,
+        };
+        await (0, store_1.saveNotificationStore)(store, this.storePath);
+    }
+    /**
+     * Emit an event to listeners
+     */
+    emit(event) {
+        if (this.onEvent) {
+            this.onEvent(event);
+        }
+    }
+}
+exports.NotificationService = NotificationService;