cowork-os 0.3.21

package/dist/electron/electron/agent/tools/builtin-settings.js

@@ -0,0 +1,384 @@
+"use strict";
+/**
+ * Settings manager for built-in tools
+ * Allows users to enable/disable and configure built-in tool categories
+ * 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.BuiltinToolsSettingsManager = void 0;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const electron_1 = require("electron");
+const SecureSettingsRepository_1 = require("../../database/SecureSettingsRepository");
+/**
+ * Default settings
+ */
+const DEFAULT_SETTINGS = {
+    categories: {
+        code: {
+            enabled: true,
+            priority: 'high',
+            description: 'Code tools (glob, grep, edit) - preferred for code navigation and editing',
+        },
+        webfetch: {
+            enabled: true,
+            priority: 'high',
+            description: 'Lightweight web fetching (preferred for reading web content)',
+        },
+        browser: {
+            enabled: true,
+            priority: 'normal',
+            description: 'Browser automation tools (navigate, click, screenshot, etc.)',
+        },
+        search: {
+            enabled: true,
+            priority: 'normal',
+            description: 'Web search tools (Brave, Tavily, etc.)',
+        },
+        system: {
+            enabled: true,
+            priority: 'normal',
+            description: 'System tools (clipboard, screenshot, open apps, etc.)',
+        },
+        file: {
+            enabled: true,
+            priority: 'normal',
+            description: 'File operations (read, write, copy, delete, etc.)',
+        },
+        skill: {
+            enabled: true,
+            priority: 'normal',
+            description: 'Document creation skills (spreadsheets, documents, presentations)',
+        },
+        shell: {
+            enabled: true,
+            priority: 'normal',
+            description: 'Shell command execution (requires workspace permission)',
+        },
+        image: {
+            enabled: true,
+            priority: 'normal',
+            description: 'AI image generation (requires Gemini API)',
+        },
+    },
+    toolOverrides: {},
+    version: '1.0.0',
+};
+/**
+ * Tool category mapping
+ */
+const TOOL_CATEGORIES = {
+    // Code tools (high priority)
+    glob: 'code',
+    grep: 'code',
+    edit_file: 'code',
+    // Web fetch tools (high priority)
+    web_fetch: 'webfetch',
+    // Browser tools
+    browser_navigate: 'browser',
+    browser_screenshot: 'browser',
+    browser_get_content: 'browser',
+    browser_click: 'browser',
+    browser_fill: 'browser',
+    browser_type: 'browser',
+    browser_press: 'browser',
+    browser_wait: 'browser',
+    browser_scroll: 'browser',
+    browser_select: 'browser',
+    browser_get_text: 'browser',
+    browser_evaluate: 'browser',
+    browser_back: 'browser',
+    browser_forward: 'browser',
+    browser_reload: 'browser',
+    browser_save_pdf: 'browser',
+    browser_close: 'browser',
+    // Search tools
+    web_search: 'search',
+    // System tools
+    system_info: 'system',
+    read_clipboard: 'system',
+    write_clipboard: 'system',
+    take_screenshot: 'system',
+    open_application: 'system',
+    open_url: 'system',
+    open_path: 'system',
+    show_in_folder: 'system',
+    get_env: 'system',
+    get_app_paths: 'system',
+    run_applescript: 'system',
+    // File tools
+    read_file: 'file',
+    write_file: 'file',
+    copy_file: 'file',
+    list_directory: 'file',
+    list_directory_with_sizes: 'file',
+    get_file_info: 'file',
+    rename_file: 'file',
+    delete_file: 'file',
+    create_directory: 'file',
+    search_files: 'file',
+    // Skill tools
+    create_spreadsheet: 'skill',
+    create_document: 'skill',
+    edit_document: 'skill',
+    create_presentation: 'skill',
+    organize_folder: 'skill',
+    // Shell tools
+    run_command: 'shell',
+    x_action: 'shell',
+    // Image tools
+    generate_image: 'image',
+};
+const LEGACY_SETTINGS_FILE = 'builtin-tools-settings.json';
+class BuiltinToolsSettingsManager {
+    /**
+     * Get the legacy settings file path
+     */
+    static getLegacySettingsPath() {
+        if (!this.legacySettingsPath) {
+            const userDataPath = electron_1.app.getPath('userData');
+            this.legacySettingsPath = path.join(userDataPath, LEGACY_SETTINGS_FILE);
+        }
+        return this.legacySettingsPath;
+    }
+    /**
+     * Migrate settings from legacy JSON file to encrypted database
+     */
+    static migrateFromLegacyFile() {
+        if (this.migrationCompleted)
+            return;
+        try {
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                return;
+            }
+            const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+            if (repository.exists('builtintools')) {
+                this.migrationCompleted = true;
+                return;
+            }
+            const legacyPath = this.getLegacySettingsPath();
+            if (!fs.existsSync(legacyPath)) {
+                this.migrationCompleted = true;
+                return;
+            }
+            console.log('[BuiltinToolsSettings] Migrating settings from legacy JSON file to encrypted database...');
+            // Create backup before migration
+            const backupPath = legacyPath + '.migration-backup';
+            fs.copyFileSync(legacyPath, backupPath);
+            try {
+                const data = fs.readFileSync(legacyPath, 'utf-8');
+                const settings = JSON.parse(data);
+                const merged = this.mergeWithDefaults(settings);
+                repository.save('builtintools', merged);
+                console.log('[BuiltinToolsSettings] Settings migrated to encrypted database');
+                // Migration successful - delete backup and original
+                fs.unlinkSync(backupPath);
+                fs.unlinkSync(legacyPath);
+                console.log('[BuiltinToolsSettings] Migration complete, cleaned up legacy files');
+                this.migrationCompleted = true;
+            }
+            catch (migrationError) {
+                console.error('[BuiltinToolsSettings] Migration failed, backup preserved at:', backupPath);
+                throw migrationError;
+            }
+        }
+        catch (error) {
+            console.error('[BuiltinToolsSettings] Migration failed:', error);
+        }
+    }
+    /**
+     * Load settings from encrypted database
+     */
+    static loadSettings() {
+        if (this.cachedSettings) {
+            return this.cachedSettings;
+        }
+        // Try migration first
+        this.migrateFromLegacyFile();
+        try {
+            if (SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+                const stored = repository.load('builtintools');
+                if (stored) {
+                    this.cachedSettings = this.mergeWithDefaults(stored);
+                    return this.cachedSettings;
+                }
+            }
+        }
+        catch (error) {
+            console.error('[BuiltinToolsSettings] Error loading settings:', error);
+        }
+        // Deep clone to prevent mutation of DEFAULT_SETTINGS
+        const defaults = JSON.parse(JSON.stringify(DEFAULT_SETTINGS));
+        this.cachedSettings = defaults;
+        return defaults;
+    }
+    /**
+     * 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();
+            repository.save('builtintools', settings);
+            this.cachedSettings = settings;
+            console.log('[BuiltinToolsSettings] Settings saved to encrypted database');
+        }
+        catch (error) {
+            console.error('[BuiltinToolsSettings] Error saving settings:', error);
+            throw error;
+        }
+    }
+    /**
+     * Merge loaded settings with defaults
+     */
+    static mergeWithDefaults(settings) {
+        // Deep clone defaults first to prevent mutation
+        const defaults = JSON.parse(JSON.stringify(DEFAULT_SETTINGS));
+        return {
+            categories: {
+                ...defaults.categories,
+                ...settings.categories,
+            },
+            toolOverrides: settings.toolOverrides || {},
+            version: settings.version || defaults.version,
+        };
+    }
+    /**
+     * Check if a tool is enabled
+     */
+    static isToolEnabled(toolName) {
+        const settings = this.loadSettings();
+        // Check individual override first
+        if (settings.toolOverrides[toolName] !== undefined) {
+            return settings.toolOverrides[toolName].enabled;
+        }
+        // Check category
+        const category = TOOL_CATEGORIES[toolName];
+        if (category && settings.categories[category]) {
+            return settings.categories[category].enabled;
+        }
+        // Default to enabled for unknown tools
+        return true;
+    }
+    /**
+     * Get tool priority
+     */
+    static getToolPriority(toolName) {
+        const settings = this.loadSettings();
+        // Check individual override first
+        if (settings.toolOverrides[toolName]?.priority) {
+            return settings.toolOverrides[toolName].priority;
+        }
+        // Check category
+        const category = TOOL_CATEGORIES[toolName];
+        if (category && settings.categories[category]) {
+            return settings.categories[category].priority;
+        }
+        return 'normal';
+    }
+    /**
+     * Get the category for a tool
+     */
+    static getToolCategory(toolName) {
+        return TOOL_CATEGORIES[toolName] || null;
+    }
+    /**
+     * Get all tool categories with their tools
+     */
+    static getToolsByCategory() {
+        const result = {};
+        for (const [tool, category] of Object.entries(TOOL_CATEGORIES)) {
+            if (!result[category]) {
+                result[category] = [];
+            }
+            result[category].push(tool);
+        }
+        return result;
+    }
+    /**
+     * Enable/disable a category
+     */
+    static setCategoryEnabled(category, enabled) {
+        const settings = this.loadSettings();
+        if (settings.categories[category]) {
+            settings.categories[category].enabled = enabled;
+            this.saveSettings(settings);
+        }
+    }
+    /**
+     * Set category priority
+     */
+    static setCategoryPriority(category, priority) {
+        const settings = this.loadSettings();
+        if (settings.categories[category]) {
+            settings.categories[category].priority = priority;
+            this.saveSettings(settings);
+        }
+    }
+    /**
+     * Set tool override
+     */
+    static setToolOverride(toolName, override) {
+        const settings = this.loadSettings();
+        if (override === null) {
+            delete settings.toolOverrides[toolName];
+        }
+        else {
+            settings.toolOverrides[toolName] = override;
+        }
+        this.saveSettings(settings);
+    }
+    /**
+     * Clear cached settings (for testing or reload)
+     */
+    static clearCache() {
+        this.cachedSettings = null;
+    }
+    /**
+     * Get default settings
+     */
+    static getDefaultSettings() {
+        // Deep clone to prevent mutation of DEFAULT_SETTINGS
+        return JSON.parse(JSON.stringify(DEFAULT_SETTINGS));
+    }
+}
+exports.BuiltinToolsSettingsManager = BuiltinToolsSettingsManager;
+BuiltinToolsSettingsManager.legacySettingsPath = null;
+BuiltinToolsSettingsManager.cachedSettings = null;
+BuiltinToolsSettingsManager.migrationCompleted = false;