cowork-os 0.3.21

package/dist/electron/electron/security/policy-manager.js

@@ -0,0 +1,435 @@
+"use strict";
+/**
+ * Security Policy Manager
+ *
+ * Implements monotonic policy precedence (deny-wins) for tool access control.
+ *
+ * Policy layers (evaluated in order):
+ * 1. Global Guardrails (blocked commands, patterns)
+ * 2. Workspace Permissions (read, write, delete, shell, network)
+ * 3. Context Restrictions (private/group/public channel context)
+ * 4. Tool-Specific Rules (per-tool overrides)
+ *
+ * Key invariant: Once a tool is denied by an earlier layer, later layers CANNOT re-enable it.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.SecurityPolicyManager = void 0;
+exports.createPolicyManager = createPolicyManager;
+exports.isToolAllowedQuick = isToolAllowedQuick;
+const types_1 = require("../../shared/types");
+/**
+ * Security Policy Manager implementing monotonic deny-wins precedence
+ */
+class SecurityPolicyManager {
+    constructor(context) {
+        this.context = context;
+        this.deniedTools = new Set();
+        this.approvalRequiredTools = new Set();
+        this.layerDecisions = new Map();
+        this.evaluateAllPolicies();
+    }
+    /**
+     * Check if a tool is allowed to execute
+     * Implements C2: Approval Gate Enforcement
+     */
+    checkToolAccess(toolName, input) {
+        // Check if tool was denied by any layer
+        if (this.deniedTools.has(toolName)) {
+            const decisions = this.layerDecisions.get(toolName) || [];
+            const denyDecision = decisions.find(d => d.decision === 'deny');
+            return {
+                allowed: false,
+                reason: denyDecision?.reason || `Tool "${toolName}" is not permitted`,
+                deniedBy: denyDecision?.layer,
+            };
+        }
+        // Check if tool requires approval
+        if (this.approvalRequiredTools.has(toolName)) {
+            const decisions = this.layerDecisions.get(toolName) || [];
+            const approvalDecision = decisions.find(d => d.decision === 'require_approval');
+            return {
+                allowed: true,
+                requiresApproval: true,
+                approvalReason: approvalDecision?.reason || `Tool "${toolName}" requires approval`,
+            };
+        }
+        // Tool-specific input validation for shell commands
+        if (toolName === 'run_command' && input?.command) {
+            const commandCheck = this.checkCommandPolicy(input.command);
+            if (!commandCheck.allowed) {
+                return commandCheck;
+            }
+        }
+        return { allowed: true };
+    }
+    /**
+     * Check if a command is allowed by guardrails
+     */
+    checkCommandPolicy(command) {
+        const { guardrails } = this.context;
+        // Check blocked patterns (always denied, cannot be overridden)
+        if (guardrails.blockDangerousCommands) {
+            const allBlockedPatterns = [
+                ...getDefaultBlockedPatterns(),
+                ...guardrails.customBlockedPatterns,
+            ];
+            for (const pattern of allBlockedPatterns) {
+                try {
+                    const regex = new RegExp(pattern, 'i');
+                    if (regex.test(command)) {
+                        return {
+                            allowed: false,
+                            reason: `Command blocked by security policy: matches pattern "${pattern}"`,
+                            deniedBy: 'global_guardrails',
+                        };
+                    }
+                }
+                catch {
+                    // Invalid regex pattern, skip
+                }
+            }
+        }
+        // Check trusted patterns (auto-approve)
+        // NOTE: Trusted patterns can NEVER override a deny - they only affect approval requirement
+        if (guardrails.autoApproveTrustedCommands) {
+            for (const pattern of guardrails.trustedCommandPatterns) {
+                if (matchGlobPattern(command, pattern)) {
+                    return {
+                        allowed: true,
+                        requiresApproval: false,
+                    };
+                }
+            }
+        }
+        // Default: requires approval for shell commands
+        return {
+            allowed: true,
+            requiresApproval: true,
+            approvalReason: 'Shell commands require approval',
+        };
+    }
+    /**
+     * Get all denied tools
+     */
+    getDeniedTools() {
+        return Array.from(this.deniedTools);
+    }
+    /**
+     * Get all tools requiring approval
+     */
+    getApprovalRequiredTools() {
+        return Array.from(this.approvalRequiredTools);
+    }
+    /**
+     * Get policy decisions for a tool (for debugging/audit)
+     */
+    getToolDecisions(toolName) {
+        return this.layerDecisions.get(toolName) || [];
+    }
+    /**
+     * Expand a tool group to individual tools
+     * Implements C4: Tool Group Expansion Accuracy
+     */
+    static expandToolGroup(groupName) {
+        return types_1.TOOL_GROUPS[groupName] || [];
+    }
+    /**
+     * Check if a tool belongs to a group
+     */
+    static isToolInGroup(toolName, groupName) {
+        const tools = types_1.TOOL_GROUPS[groupName];
+        return tools ? tools.includes(toolName) : false;
+    }
+    /**
+     * Get risk level for a tool
+     */
+    static getToolRiskLevel(toolName) {
+        return types_1.TOOL_RISK_LEVELS[toolName];
+    }
+    // Private methods
+    /**
+     * Evaluate all policy layers and build the denied/approval-required sets
+     * Key invariant: Once denied, a tool stays denied (monotonic)
+     */
+    evaluateAllPolicies() {
+        const allTools = this.getAllKnownTools();
+        for (const toolName of allTools) {
+            const decisions = [];
+            // Layer 1: Global Guardrails
+            const guardrailDecision = this.evaluateGuardrailLayer(toolName);
+            decisions.push(guardrailDecision);
+            if (guardrailDecision.decision === 'deny') {
+                this.deniedTools.add(toolName);
+                this.layerDecisions.set(toolName, decisions);
+                continue; // Monotonic: skip remaining layers
+            }
+            // Layer 2: Workspace Permissions
+            const workspaceDecision = this.evaluateWorkspaceLayer(toolName);
+            decisions.push(workspaceDecision);
+            if (workspaceDecision.decision === 'deny') {
+                this.deniedTools.add(toolName);
+                this.layerDecisions.set(toolName, decisions);
+                continue; // Monotonic: skip remaining layers
+            }
+            // Layer 3: Context Restrictions (if gateway context is set)
+            if (this.context.gatewayContext) {
+                const contextDecision = this.evaluateContextLayer(toolName);
+                decisions.push(contextDecision);
+                if (contextDecision.decision === 'deny') {
+                    this.deniedTools.add(toolName);
+                    this.layerDecisions.set(toolName, decisions);
+                    continue; // Monotonic: skip remaining layers
+                }
+                if (contextDecision.decision === 'require_approval') {
+                    this.approvalRequiredTools.add(toolName);
+                }
+            }
+            // Layer 4: Tool-Specific Rules
+            const toolSpecificDecision = this.evaluateToolSpecificLayer(toolName);
+            decisions.push(toolSpecificDecision);
+            if (toolSpecificDecision.decision === 'deny') {
+                this.deniedTools.add(toolName);
+            }
+            else if (toolSpecificDecision.decision === 'require_approval') {
+                this.approvalRequiredTools.add(toolName);
+            }
+            this.layerDecisions.set(toolName, decisions);
+        }
+    }
+    /**
+     * Layer 1: Global Guardrails
+     */
+    evaluateGuardrailLayer(toolName) {
+        const { guardrails } = this.context;
+        // Network tools require network to be allowed in guardrails
+        if (SecurityPolicyManager.isToolInGroup(toolName, 'group:network')) {
+            if (guardrails.enforceAllowedDomains && guardrails.allowedDomains.length === 0) {
+                return {
+                    layer: 'global_guardrails',
+                    decision: 'deny',
+                    reason: 'Network tools blocked: no allowed domains configured',
+                };
+            }
+        }
+        return { layer: 'global_guardrails', decision: 'pass' };
+    }
+    /**
+     * Layer 2: Workspace Permissions
+     */
+    evaluateWorkspaceLayer(toolName) {
+        const { workspace } = this.context;
+        const permissions = workspace.permissions;
+        // Check read permission
+        if (SecurityPolicyManager.isToolInGroup(toolName, 'group:read')) {
+            if (!permissions.read) {
+                return {
+                    layer: 'workspace_permissions',
+                    decision: 'deny',
+                    reason: 'Workspace does not have read permission',
+                };
+            }
+        }
+        // Check write permission
+        if (SecurityPolicyManager.isToolInGroup(toolName, 'group:write')) {
+            if (!permissions.write) {
+                return {
+                    layer: 'workspace_permissions',
+                    decision: 'deny',
+                    reason: 'Workspace does not have write permission',
+                };
+            }
+        }
+        // Check delete permission
+        if (toolName === 'delete_file') {
+            if (!permissions.delete) {
+                return {
+                    layer: 'workspace_permissions',
+                    decision: 'require_approval',
+                    reason: 'File deletion requires approval (delete permission not granted)',
+                };
+            }
+        }
+        // Check shell permission
+        if (toolName === 'run_command') {
+            if (!permissions.shell) {
+                return {
+                    layer: 'workspace_permissions',
+                    decision: 'deny',
+                    reason: 'Workspace does not have shell permission',
+                };
+            }
+            // Shell commands always require approval even with permission
+            return {
+                layer: 'workspace_permissions',
+                decision: 'require_approval',
+                reason: 'Shell commands require approval',
+            };
+        }
+        // Check network permission
+        if (SecurityPolicyManager.isToolInGroup(toolName, 'group:network')) {
+            if (!permissions.network) {
+                return {
+                    layer: 'workspace_permissions',
+                    decision: 'deny',
+                    reason: 'Workspace does not have network permission',
+                };
+            }
+        }
+        return { layer: 'workspace_permissions', decision: 'pass' };
+    }
+    /**
+     * Layer 3: Context Restrictions (Gateway context)
+     * Implements C1: Memory Tool Isolation in Shared Contexts
+     */
+    evaluateContextLayer(toolName) {
+        const contextType = this.context.gatewayContext;
+        if (!contextType) {
+            return { layer: 'context_restrictions', decision: 'pass' };
+        }
+        const restrictions = types_1.CONTEXT_TOOL_RESTRICTIONS[contextType];
+        // Check if tool is explicitly denied
+        if (restrictions.deniedTools.includes(toolName)) {
+            return {
+                layer: 'context_restrictions',
+                decision: 'deny',
+                reason: `Tool "${toolName}" is not allowed in ${contextType} context`,
+            };
+        }
+        // Check if tool's group is denied
+        for (const groupName of restrictions.deniedGroups) {
+            if (SecurityPolicyManager.isToolInGroup(toolName, groupName)) {
+                return {
+                    layer: 'context_restrictions',
+                    decision: 'deny',
+                    reason: `Tool group "${groupName}" is not allowed in ${contextType} context`,
+                };
+            }
+        }
+        // Check if tool requires approval in this context
+        if (restrictions.requireApprovalFor.includes(toolName)) {
+            return {
+                layer: 'context_restrictions',
+                decision: 'require_approval',
+                reason: `Tool "${toolName}" requires approval in ${contextType} context`,
+            };
+        }
+        return { layer: 'context_restrictions', decision: 'pass' };
+    }
+    /**
+     * Layer 4: Tool-Specific Rules
+     */
+    evaluateToolSpecificLayer(toolName) {
+        // Destructive tools always require approval
+        const riskLevel = SecurityPolicyManager.getToolRiskLevel(toolName);
+        if (riskLevel === 'destructive') {
+            return {
+                layer: 'tool_specific',
+                decision: 'require_approval',
+                reason: `Destructive tool "${toolName}" requires approval`,
+            };
+        }
+        return { layer: 'tool_specific', decision: 'pass' };
+    }
+    /**
+     * Get all known tool names
+     */
+    getAllKnownTools() {
+        const tools = new Set();
+        // Add all tools from groups
+        for (const groupTools of Object.values(types_1.TOOL_GROUPS)) {
+            for (const tool of groupTools) {
+                tools.add(tool);
+            }
+        }
+        // Add tools from TOOL_RISK_LEVELS
+        for (const tool of Object.keys(types_1.TOOL_RISK_LEVELS)) {
+            tools.add(tool);
+        }
+        return Array.from(tools);
+    }
+}
+exports.SecurityPolicyManager = SecurityPolicyManager;
+/**
+ * Default blocked command patterns (security-critical)
+ */
+function getDefaultBlockedPatterns() {
+    return [
+        'sudo',
+        'rm\\s+-rf\\s+/',
+        'rm\\s+-rf\\s+~',
+        'rm\\s+-rf\\s+/\\*',
+        'rm\\s+-rf\\s+\\*',
+        'mkfs',
+        'dd\\s+if=',
+        ':\\(\\)\\{\\s*:\\|:\\&\\s*\\};:', // Fork bomb
+        'curl.*\\|.*bash',
+        'wget.*\\|.*bash',
+        'curl.*\\|.*sh',
+        'wget.*\\|.*sh',
+        'chmod\\s+777',
+        '>\\s*/dev/sd',
+        'mv\\s+/\\*',
+        'format\\s+c:',
+        'del\\s+/f\\s+/s\\s+/q',
+    ];
+}
+/**
+ * Match a command against a glob-like pattern
+ */
+function matchGlobPattern(command, pattern) {
+    // Convert glob pattern to regex
+    const regexPattern = pattern
+        .replace(/[.+^${}()|[\]\\]/g, '\\$&') // Escape special chars except * and ?
+        .replace(/\*/g, '.*')
+        .replace(/\?/g, '.');
+    try {
+        const regex = new RegExp(`^${regexPattern}$`, 'i');
+        return regex.test(command);
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Create a policy manager for a workspace context
+ */
+function createPolicyManager(workspace, guardrails, gatewayContext) {
+    return new SecurityPolicyManager({
+        workspace,
+        guardrails,
+        gatewayContext,
+    });
+}
+/**
+ * Quick check if a tool is allowed (without full policy evaluation)
+ * Use for filtering tool lists before presenting to LLM
+ */
+function isToolAllowedQuick(toolName, workspace, gatewayContext) {
+    const permissions = workspace.permissions;
+    // Check basic permissions
+    if (SecurityPolicyManager.isToolInGroup(toolName, 'group:read') && !permissions.read) {
+        return false;
+    }
+    if (SecurityPolicyManager.isToolInGroup(toolName, 'group:write') && !permissions.write) {
+        return false;
+    }
+    if (toolName === 'run_command' && !permissions.shell) {
+        return false;
+    }
+    if (SecurityPolicyManager.isToolInGroup(toolName, 'group:network') && !permissions.network) {
+        return false;
+    }
+    // Check context restrictions
+    if (gatewayContext) {
+        const restrictions = types_1.CONTEXT_TOOL_RESTRICTIONS[gatewayContext];
+        if (restrictions.deniedTools.includes(toolName)) {
+            return false;
+        }
+        for (const groupName of restrictions.deniedGroups) {
+            if (SecurityPolicyManager.isToolInGroup(toolName, groupName)) {
+                return false;
+            }
+        }
+    }
+    return true;
+}

package/dist/electron/electron/settings/appearance-manager.js

@@ -0,0 +1,193 @@
+"use strict";
+/**
+ * Appearance Settings Manager
+ *
+ * Manages user appearance preferences (theme and accent color).
+ * 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.AppearanceManager = void 0;
+const electron_1 = require("electron");
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const SecureSettingsRepository_1 = require("../database/SecureSettingsRepository");
+const LEGACY_SETTINGS_FILE = 'appearance-settings.json';
+const DEFAULT_SETTINGS = {
+    themeMode: 'dark',
+    accentColor: 'cyan',
+    disclaimerAccepted: false,
+    onboardingCompleted: false,
+    onboardingCompletedAt: undefined,
+};
+class AppearanceManager {
+    /**
+     * Initialize the AppearanceManager
+     */
+    static initialize() {
+        const userDataPath = electron_1.app.getPath('userData');
+        this.legacySettingsPath = path.join(userDataPath, LEGACY_SETTINGS_FILE);
+        console.log('[AppearanceManager] Initialized');
+        // 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('[AppearanceManager] SecureSettingsRepository not yet initialized, skipping migration');
+                return;
+            }
+            const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+            // Check if already migrated to database
+            if (repository.exists('appearance')) {
+                this.migrationCompleted = true;
+                return;
+            }
+            // Check if legacy file exists
+            if (!fs.existsSync(this.legacySettingsPath)) {
+                console.log('[AppearanceManager] No legacy settings file found');
+                this.migrationCompleted = true;
+                return;
+            }
+            console.log('[AppearanceManager] 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);
+                const legacySettings = { ...DEFAULT_SETTINGS, ...parsed };
+                // Save to encrypted database
+                repository.save('appearance', legacySettings);
+                console.log('[AppearanceManager] Settings migrated to encrypted database');
+                // Migration successful - delete backup and original
+                fs.unlinkSync(backupPath);
+                fs.unlinkSync(this.legacySettingsPath);
+                console.log('[AppearanceManager] Migration complete, cleaned up legacy files');
+                this.migrationCompleted = true;
+            }
+            catch (migrationError) {
+                console.error('[AppearanceManager] Migration failed, backup preserved at:', backupPath);
+                throw migrationError;
+            }
+        }
+        catch (error) {
+            console.error('[AppearanceManager] Migration failed:', error);
+        }
+    }
+    /**
+     * Load settings from encrypted database (with caching)
+     */
+    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('appearance');
+                if (stored) {
+                    settings = { ...DEFAULT_SETTINGS, ...stored };
+                }
+            }
+            // Validate values
+            if (!isValidThemeMode(settings.themeMode)) {
+                settings.themeMode = DEFAULT_SETTINGS.themeMode;
+            }
+            if (!isValidAccentColor(settings.accentColor)) {
+                settings.accentColor = DEFAULT_SETTINGS.accentColor;
+            }
+        }
+        catch (error) {
+            console.error('[AppearanceManager] Failed to load settings:', error);
+            settings = { ...DEFAULT_SETTINGS };
+        }
+        this.cachedSettings = settings;
+        return settings;
+    }
+    /**
+     * Save settings to encrypted database
+     */
+    static saveSettings(settings) {
+        try {
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                throw new Error('SecureSettingsRepository not initialized');
+            }
+            // Load existing settings to preserve fields not being updated
+            const existingSettings = this.loadSettings();
+            // Validate and merge with existing settings
+            const validatedSettings = {
+                themeMode: isValidThemeMode(settings.themeMode) ? settings.themeMode : existingSettings.themeMode,
+                accentColor: isValidAccentColor(settings.accentColor) ? settings.accentColor : existingSettings.accentColor,
+                disclaimerAccepted: settings.disclaimerAccepted ?? existingSettings.disclaimerAccepted,
+                onboardingCompleted: settings.onboardingCompleted ?? existingSettings.onboardingCompleted,
+                onboardingCompletedAt: settings.onboardingCompletedAt ?? existingSettings.onboardingCompletedAt,
+            };
+            const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+            repository.save('appearance', validatedSettings);
+            this.cachedSettings = validatedSettings;
+            console.log('[AppearanceManager] Settings saved to encrypted database');
+        }
+        catch (error) {
+            console.error('[AppearanceManager] Failed to save settings:', error);
+            throw error;
+        }
+    }
+    /**
+     * Clear the settings cache
+     */
+    static clearCache() {
+        this.cachedSettings = null;
+    }
+}
+exports.AppearanceManager = AppearanceManager;
+AppearanceManager.cachedSettings = null;
+AppearanceManager.migrationCompleted = false;
+function isValidThemeMode(value) {
+    return value === 'light' || value === 'dark' || value === 'system';
+}
+function isValidAccentColor(value) {
+    const validColors = ['cyan', 'blue', 'purple', 'pink', 'rose', 'orange', 'green', 'teal'];
+    return validColors.includes(value);
+}