cowork-os 0.3.21

package/dist/electron/electron/agent/search/provider-factory.js

@@ -0,0 +1,395 @@
+"use strict";
+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.SearchProviderFactory = void 0;
+const electron_1 = require("electron");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const types_1 = require("./types");
+const tavily_provider_1 = require("./tavily-provider");
+const brave_provider_1 = require("./brave-provider");
+const serpapi_provider_1 = require("./serpapi-provider");
+const google_provider_1 = require("./google-provider");
+const SecureSettingsRepository_1 = require("../../database/SecureSettingsRepository");
+const LEGACY_SETTINGS_FILE = 'search-settings.json';
+const DEFAULT_SETTINGS = {
+    primaryProvider: null,
+    fallbackProvider: null,
+};
+/**
+ * Factory for creating Search providers with fallback support
+ */
+class SearchProviderFactory {
+    /**
+     * Initialize the factory
+     */
+    static initialize() {
+        const userDataPath = electron_1.app.getPath('userData');
+        this.legacySettingsPath = path.join(userDataPath, LEGACY_SETTINGS_FILE);
+        // Migrate from legacy JSON file to encrypted database
+        this.migrateFromLegacyFile();
+    }
+    /**
+     * Migrate settings from legacy JSON file to encrypted database
+     */
+    static migrateFromLegacyFile() {
+        if (this.migrationCompleted)
+            return;
+        try {
+            // Check if SecureSettingsRepository is initialized
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                console.log('[SearchProviderFactory] SecureSettingsRepository not yet initialized, skipping migration');
+                return;
+            }
+            const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+            // Check if already migrated to database
+            if (repository.exists('search')) {
+                this.migrationCompleted = true;
+                return;
+            }
+            // Check if legacy file exists
+            if (!fs.existsSync(this.legacySettingsPath)) {
+                console.log('[SearchProviderFactory] No legacy settings file found');
+                this.migrationCompleted = true;
+                return;
+            }
+            console.log('[SearchProviderFactory] 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 {
+                // Read legacy settings
+                const data = fs.readFileSync(this.legacySettingsPath, 'utf-8');
+                const parsed = JSON.parse(data);
+                // Handle migration from old format (providerType -> primaryProvider)
+                if (parsed.providerType && !parsed.primaryProvider) {
+                    parsed.primaryProvider = parsed.providerType;
+                    delete parsed.providerType;
+                }
+                const legacySettings = { ...DEFAULT_SETTINGS, ...parsed };
+                // Save to encrypted database
+                repository.save('search', legacySettings);
+                console.log('[SearchProviderFactory] Settings migrated to encrypted database');
+                // Migration successful - delete backup and original
+                fs.unlinkSync(backupPath);
+                fs.unlinkSync(this.legacySettingsPath);
+                console.log('[SearchProviderFactory] Migration complete, cleaned up legacy files');
+                this.migrationCompleted = true;
+            }
+            catch (migrationError) {
+                console.error('[SearchProviderFactory] Migration failed, backup preserved at:', backupPath);
+                throw migrationError;
+            }
+        }
+        catch (error) {
+            console.error('[SearchProviderFactory] Migration failed:', error);
+        }
+    }
+    /**
+     * Get the path to legacy settings file (for testing)
+     */
+    static getSettingsPath() {
+        return this.legacySettingsPath;
+    }
+    /**
+     * Load settings from encrypted database
+     */
+    static loadSettings() {
+        if (this.cachedSettings) {
+            return this.cachedSettings;
+        }
+        let settings = { ...DEFAULT_SETTINGS };
+        try {
+            // Try to load from encrypted database
+            if (SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+                const stored = repository.load('search');
+                if (stored) {
+                    settings = { ...DEFAULT_SETTINGS, ...stored };
+                }
+            }
+        }
+        catch (error) {
+            console.error('[SearchProviderFactory] Failed to load settings from database:', error);
+        }
+        // Auto-detect and select providers if primaryProvider is not set
+        if (!settings.primaryProvider) {
+            const configuredProviders = this.getConfiguredProvidersFromSettings(settings);
+            if (configuredProviders.length > 0) {
+                settings.primaryProvider = configuredProviders[0];
+                console.log(`[SearchProviderFactory] Auto-selected primary provider: ${configuredProviders[0]}`);
+                if (configuredProviders.length > 1 && !settings.fallbackProvider) {
+                    settings.fallbackProvider = configuredProviders[1];
+                    console.log(`[SearchProviderFactory] Auto-selected fallback provider: ${configuredProviders[1]}`);
+                }
+            }
+        }
+        this.cachedSettings = settings;
+        return settings;
+    }
+    /**
+     * Get list of configured provider types from settings only
+     * Note: Environment variables are no longer used for security reasons.
+     */
+    static getConfiguredProvidersFromSettings(settings) {
+        const configured = [];
+        // Check Tavily
+        if (settings.tavily?.apiKey) {
+            configured.push('tavily');
+        }
+        // Check Brave
+        if (settings.brave?.apiKey) {
+            configured.push('brave');
+        }
+        // Check SerpAPI
+        if (settings.serpapi?.apiKey) {
+            configured.push('serpapi');
+        }
+        // Check Google (requires both API key and Search Engine ID)
+        if (settings.google?.apiKey && settings.google?.searchEngineId) {
+            configured.push('google');
+        }
+        return configured;
+    }
+    /**
+     * Save settings to encrypted database
+     */
+    static saveSettings(settings) {
+        try {
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                throw new Error('SecureSettingsRepository not initialized');
+            }
+            const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+            // Load existing settings to preserve API keys that weren't changed
+            let existingSettings = { ...DEFAULT_SETTINGS };
+            const stored = repository.load('search');
+            if (stored) {
+                existingSettings = stored;
+            }
+            // Merge settings, preserving existing API keys if new ones aren't provided
+            const settingsToSave = {
+                primaryProvider: settings.primaryProvider,
+                fallbackProvider: settings.fallbackProvider,
+                tavily: settings.tavily?.apiKey
+                    ? settings.tavily
+                    : existingSettings.tavily,
+                brave: settings.brave?.apiKey
+                    ? settings.brave
+                    : existingSettings.brave,
+                serpapi: settings.serpapi?.apiKey
+                    ? settings.serpapi
+                    : existingSettings.serpapi,
+                google: settings.google?.apiKey || settings.google?.searchEngineId
+                    ? { ...existingSettings.google, ...settings.google }
+                    : existingSettings.google,
+            };
+            // Save to encrypted database
+            repository.save('search', settingsToSave);
+            this.cachedSettings = settingsToSave;
+            console.log('[SearchProviderFactory] Settings saved to encrypted database');
+        }
+        catch (error) {
+            console.error('[SearchProviderFactory] Failed to save settings:', error);
+            throw error;
+        }
+    }
+    /**
+     * Clear cached settings
+     */
+    static clearCache() {
+        this.cachedSettings = null;
+    }
+    /**
+     * Get the config for creating a provider
+     * Note: All credentials must be configured via the Settings UI.
+     */
+    static getProviderConfig(providerType) {
+        const settings = this.loadSettings();
+        return {
+            type: providerType,
+            tavilyApiKey: settings.tavily?.apiKey,
+            braveApiKey: settings.brave?.apiKey,
+            serpApiKey: settings.serpapi?.apiKey,
+            googleApiKey: settings.google?.apiKey,
+            googleSearchEngineId: settings.google?.searchEngineId,
+        };
+    }
+    /**
+     * Create a provider based on current settings or override
+     */
+    static createProvider(overrideType) {
+        const settings = this.loadSettings();
+        const providerType = overrideType || settings.primaryProvider;
+        if (!providerType) {
+            throw new Error('No search provider configured');
+        }
+        const config = this.getProviderConfig(providerType);
+        return this.createProviderFromConfig(config);
+    }
+    /**
+     * Create provider from explicit config
+     */
+    static createProviderFromConfig(config) {
+        switch (config.type) {
+            case 'tavily':
+                return new tavily_provider_1.TavilyProvider(config);
+            case 'brave':
+                return new brave_provider_1.BraveProvider(config);
+            case 'serpapi':
+                return new serpapi_provider_1.SerpApiProvider(config);
+            case 'google':
+                return new google_provider_1.GoogleProvider(config);
+            default:
+                throw new Error(`Unknown search provider type: ${config.type}`);
+        }
+    }
+    /**
+     * Execute a search with automatic fallback on failure
+     */
+    static async searchWithFallback(query) {
+        const settings = this.loadSettings();
+        const primaryType = query.provider || settings.primaryProvider;
+        if (!primaryType) {
+            throw new Error('No search provider configured');
+        }
+        // Try primary provider
+        try {
+            const primaryConfig = this.getProviderConfig(primaryType);
+            const primaryProvider = this.createProviderFromConfig(primaryConfig);
+            return await primaryProvider.search(query);
+        }
+        catch (primaryError) {
+            console.error(`Primary search provider (${primaryType}) failed:`, primaryError.message);
+            // If a specific provider was requested, don't fallback
+            if (query.provider) {
+                throw primaryError;
+            }
+            // Try fallback provider if configured
+            const fallbackType = settings.fallbackProvider;
+            if (fallbackType && fallbackType !== primaryType) {
+                console.log(`Attempting fallback to ${fallbackType}...`);
+                try {
+                    const fallbackConfig = this.getProviderConfig(fallbackType);
+                    const fallbackProvider = this.createProviderFromConfig(fallbackConfig);
+                    const response = await fallbackProvider.search(query);
+                    // Indicate this came from fallback
+                    console.log(`Fallback search with ${fallbackType} succeeded`);
+                    return response;
+                }
+                catch (fallbackError) {
+                    console.error(`Fallback search provider (${fallbackType}) also failed:`, fallbackError.message);
+                    // Throw the original error
+                    throw new Error(`Primary provider (${primaryType}) failed: ${primaryError.message}. ` +
+                        `Fallback provider (${fallbackType}) also failed: ${fallbackError.message}`);
+                }
+            }
+            throw primaryError;
+        }
+    }
+    /**
+     * Get available providers based on saved configuration
+     * Note: Environment variables are no longer checked for security reasons.
+     */
+    static getAvailableProviders() {
+        const settings = this.loadSettings();
+        return [
+            {
+                type: 'tavily',
+                name: types_1.SEARCH_PROVIDER_INFO.tavily.displayName,
+                description: types_1.SEARCH_PROVIDER_INFO.tavily.description,
+                configured: !!settings.tavily?.apiKey,
+                supportedTypes: [...types_1.SEARCH_PROVIDER_INFO.tavily.supportedTypes],
+            },
+            {
+                type: 'brave',
+                name: types_1.SEARCH_PROVIDER_INFO.brave.displayName,
+                description: types_1.SEARCH_PROVIDER_INFO.brave.description,
+                configured: !!settings.brave?.apiKey,
+                supportedTypes: [...types_1.SEARCH_PROVIDER_INFO.brave.supportedTypes],
+            },
+            {
+                type: 'serpapi',
+                name: types_1.SEARCH_PROVIDER_INFO.serpapi.displayName,
+                description: types_1.SEARCH_PROVIDER_INFO.serpapi.description,
+                configured: !!settings.serpapi?.apiKey,
+                supportedTypes: [...types_1.SEARCH_PROVIDER_INFO.serpapi.supportedTypes],
+            },
+            {
+                type: 'google',
+                name: types_1.SEARCH_PROVIDER_INFO.google.displayName,
+                description: types_1.SEARCH_PROVIDER_INFO.google.description,
+                configured: !!(settings.google?.apiKey && settings.google?.searchEngineId),
+                supportedTypes: [...types_1.SEARCH_PROVIDER_INFO.google.supportedTypes],
+            },
+        ];
+    }
+    /**
+     * Check if any search provider is configured
+     */
+    static isAnyProviderConfigured() {
+        return this.getAvailableProviders().some((p) => p.configured);
+    }
+    /**
+     * Get current configuration status
+     */
+    static getConfigStatus() {
+        const settings = this.loadSettings();
+        return {
+            primaryProvider: settings.primaryProvider,
+            fallbackProvider: settings.fallbackProvider,
+            providers: this.getAvailableProviders(),
+            isConfigured: this.isAnyProviderConfigured(),
+        };
+    }
+    /**
+     * Test a provider configuration
+     */
+    static async testProvider(providerType) {
+        try {
+            const config = this.getProviderConfig(providerType);
+            const provider = this.createProviderFromConfig(config);
+            return await provider.testConnection();
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to create provider',
+            };
+        }
+    }
+}
+exports.SearchProviderFactory = SearchProviderFactory;
+SearchProviderFactory.cachedSettings = null;
+SearchProviderFactory.migrationCompleted = false;

package/dist/electron/electron/agent/search/serpapi-provider.js

@@ -0,0 +1,112 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SerpApiProvider = void 0;
+/**
+ * SerpAPI provider - aggregates multiple search engines
+ * https://serpapi.com/
+ */
+class SerpApiProvider {
+    constructor(config) {
+        this.type = 'serpapi';
+        this.supportedSearchTypes = ['web', 'news', 'images'];
+        this.baseUrl = 'https://serpapi.com/search.json';
+        const apiKey = config.serpApiKey;
+        if (!apiKey) {
+            throw new Error('SerpAPI key is required. Configure it in Settings or get one from https://serpapi.com/');
+        }
+        this.apiKey = apiKey;
+    }
+    async search(query) {
+        const searchType = query.searchType || 'web';
+        if (!this.supportedSearchTypes.includes(searchType)) {
+            throw new Error(`SerpAPI does not support ${searchType} search`);
+        }
+        const params = new URLSearchParams({
+            api_key: this.apiKey,
+            q: query.query,
+            engine: 'google',
+            num: String(query.maxResults || 10),
+            ...(query.region && { gl: query.region }),
+            ...(query.language && { hl: query.language }),
+            ...(query.safeSearch !== undefined && {
+                safe: query.safeSearch ? 'active' : 'off',
+            }),
+            ...(searchType === 'images' && { tbm: 'isch' }),
+            ...(searchType === 'news' && { tbm: 'nws' }),
+            ...(query.dateRange && { tbs: this.mapDateRange(query.dateRange) }),
+        });
+        const response = await fetch(`${this.baseUrl}?${params}`);
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`SerpAPI error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        if (data.error) {
+            throw new Error(`SerpAPI error: ${data.error}`);
+        }
+        return {
+            results: this.mapResults(data, searchType),
+            query: query.query,
+            searchType,
+            totalResults: data.search_information?.total_results,
+            provider: 'serpapi',
+        };
+    }
+    async testConnection() {
+        try {
+            await this.search({ query: 'test', maxResults: 1 });
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to connect to SerpAPI',
+            };
+        }
+    }
+    mapDateRange(range) {
+        switch (range) {
+            case 'day':
+                return 'qdr:d';
+            case 'week':
+                return 'qdr:w';
+            case 'month':
+                return 'qdr:m';
+            case 'year':
+                return 'qdr:y';
+            default:
+                return 'qdr:w';
+        }
+    }
+    mapResults(data, searchType) {
+        if (searchType === 'images') {
+            return (data.images_results || []).map((r) => ({
+                title: r.title || '',
+                url: r.link || r.original || '',
+                snippet: r.snippet || '',
+                thumbnailUrl: r.thumbnail,
+                imageUrl: r.original,
+                width: r.original_width,
+                height: r.original_height,
+                source: r.source,
+            }));
+        }
+        if (searchType === 'news') {
+            return (data.news_results || []).map((r) => ({
+                title: r.title || '',
+                url: r.link || '',
+                snippet: r.snippet || '',
+                publishedDate: r.date,
+                source: r.source,
+            }));
+        }
+        // Web (organic) results
+        return (data.organic_results || []).map((r) => ({
+            title: r.title || '',
+            url: r.link || '',
+            snippet: r.snippet || '',
+            source: r.displayed_link,
+        }));
+    }
+}
+exports.SerpApiProvider = SerpApiProvider;

package/dist/electron/electron/agent/search/tavily-provider.js

@@ -0,0 +1,90 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TavilyProvider = void 0;
+/**
+ * Tavily Search API provider
+ * https://docs.tavily.com/
+ */
+class TavilyProvider {
+    constructor(config) {
+        this.type = 'tavily';
+        this.supportedSearchTypes = ['web', 'news'];
+        this.baseUrl = 'https://api.tavily.com';
+        const apiKey = config.tavilyApiKey;
+        if (!apiKey) {
+            throw new Error('Tavily API key is required. Configure it in Settings or get one from https://tavily.com/');
+        }
+        this.apiKey = apiKey;
+    }
+    async search(query) {
+        const searchType = query.searchType || 'web';
+        if (!this.supportedSearchTypes.includes(searchType)) {
+            throw new Error(`Tavily does not support ${searchType} search. Supported: ${this.supportedSearchTypes.join(', ')}`);
+        }
+        const response = await fetch(`${this.baseUrl}/search`, {
+            method: 'POST',
+            headers: {
+                'Content-Type': 'application/json',
+            },
+            body: JSON.stringify({
+                api_key: this.apiKey,
+                query: query.query,
+                search_depth: 'advanced',
+                max_results: query.maxResults || 10,
+                include_answer: false,
+                include_raw_content: false,
+                // Tavily-specific: topic for news
+                topic: searchType === 'news' ? 'news' : 'general',
+                // Date filter if specified
+                ...(query.dateRange && { days: this.dateRangeToDays(query.dateRange) }),
+            }),
+        });
+        if (!response.ok) {
+            const error = await response.text();
+            throw new Error(`Tavily API error: ${response.status} - ${error}`);
+        }
+        const data = await response.json();
+        return {
+            results: this.mapResults(data.results || []),
+            query: query.query,
+            searchType,
+            provider: 'tavily',
+        };
+    }
+    async testConnection() {
+        try {
+            await this.search({ query: 'test', maxResults: 1 });
+            return { success: true };
+        }
+        catch (error) {
+            return {
+                success: false,
+                error: error.message || 'Failed to connect to Tavily API',
+            };
+        }
+    }
+    mapResults(results) {
+        return results.map((r) => ({
+            title: r.title || '',
+            url: r.url || '',
+            snippet: r.content || r.snippet || '',
+            publishedDate: r.published_date,
+            source: r.source,
+        }));
+    }
+    dateRangeToDays(range) {
+        switch (range) {
+            case 'day':
+                return 1;
+            case 'week':
+                return 7;
+            case 'month':
+                return 30;
+            case 'year':
+                return 365;
+            default:
+                return 7;
+        }
+    }
+}
+exports.TavilyProvider = TavilyProvider;

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

@@ -0,0 +1,40 @@
+"use strict";
+/**
+ * Search Provider abstraction types
+ * Allows switching between Tavily, Brave Search, SerpAPI, and Google Custom Search
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SEARCH_PROVIDER_INFO = void 0;
+/**
+ * Provider capabilities for UI display
+ */
+exports.SEARCH_PROVIDER_INFO = {
+    tavily: {
+        displayName: 'Tavily',
+        description: 'AI-focused search API with structured results',
+        supportedTypes: ['web', 'news'],
+        envVar: 'TAVILY_API_KEY',
+        signupUrl: 'https://tavily.com/',
+    },
+    brave: {
+        displayName: 'Brave Search',
+        description: 'Privacy-focused web, news, and image search',
+        supportedTypes: ['web', 'news', 'images'],
+        envVar: 'BRAVE_API_KEY',
+        signupUrl: 'https://brave.com/search/api/',
+    },
+    serpapi: {
+        displayName: 'SerpAPI',
+        description: 'Aggregates Google, Bing, DuckDuckGo results',
+        supportedTypes: ['web', 'news', 'images'],
+        envVar: 'SERPAPI_KEY',
+        signupUrl: 'https://serpapi.com/',
+    },
+    google: {
+        displayName: 'Google Custom Search',
+        description: 'Official Google Search API',
+        supportedTypes: ['web', 'images'],
+        envVars: ['GOOGLE_API_KEY', 'GOOGLE_SEARCH_ENGINE_ID'],
+        signupUrl: 'https://developers.google.com/custom-search/v1/introduction',
+    },
+};

package/dist/electron/electron/agent/security/index.js

@@ -0,0 +1,12 @@
+"use strict";
+/**
+ * Security Module
+ *
+ * Exports all security-related utilities for the agent system.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.OutputFilter = exports.InputSanitizer = void 0;
+var input_sanitizer_1 = require("./input-sanitizer");
+Object.defineProperty(exports, "InputSanitizer", { enumerable: true, get: function () { return input_sanitizer_1.InputSanitizer; } });
+var output_filter_1 = require("./output-filter");
+Object.defineProperty(exports, "OutputFilter", { enumerable: true, get: function () { return output_filter_1.OutputFilter; } });