cowork-os 0.3.21

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

@@ -0,0 +1,359 @@
+"use strict";
+/**
+ * Voice Settings Manager
+ *
+ * Manages voice settings persistence using the encrypted database.
+ * All settings (including API keys) are stored encrypted in the database
+ * using the 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.VoiceSettingsManager = 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");
+// Legacy file names for migration
+const LEGACY_SETTINGS_FILE = 'voice-settings.json';
+const LEGACY_SECURE_KEYS_FILE = 'voice-keys.enc';
+class VoiceSettingsManager {
+    /**
+     * Initialize the VoiceSettingsManager with the database
+     */
+    static initialize(db) {
+        this.userDataPath = electron_1.app.getPath('userData');
+        if (db) {
+            this.repository = new SecureSettingsRepository_1.SecureSettingsRepository(db);
+            console.log('[VoiceSettingsManager] Initialized with secure database storage');
+            // Migrate from legacy JSON files if needed
+            this.migrateFromLegacyFiles();
+        }
+        else {
+            console.warn('[VoiceSettingsManager] No database provided, will initialize on first use');
+        }
+    }
+    /**
+     * Set the repository (called after database is ready)
+     */
+    static setRepository(db) {
+        this.repository = new SecureSettingsRepository_1.SecureSettingsRepository(db);
+        console.log('[VoiceSettingsManager] Repository set');
+        // Migrate from legacy JSON files if needed
+        if (!this.migrationComplete) {
+            this.migrateFromLegacyFiles();
+        }
+    }
+    /**
+     * Load voice settings from encrypted database
+     */
+    static loadSettings() {
+        if (this.cachedSettings) {
+            return this.cachedSettings;
+        }
+        let settings = { ...types_1.DEFAULT_VOICE_SETTINGS };
+        try {
+            if (this.repository) {
+                const stored = this.repository.load('voice');
+                if (stored) {
+                    settings = {
+                        ...types_1.DEFAULT_VOICE_SETTINGS,
+                        ...stored,
+                    };
+                    // Validate values
+                    settings = this.validateSettings(settings);
+                }
+            }
+            else {
+                console.warn('[VoiceSettingsManager] Repository not initialized, using defaults');
+            }
+        }
+        catch (error) {
+            console.error('[VoiceSettingsManager] Failed to load settings:', error);
+            settings = { ...types_1.DEFAULT_VOICE_SETTINGS };
+        }
+        this.cachedSettings = settings;
+        return settings;
+    }
+    /**
+     * Save voice settings to encrypted database
+     */
+    static saveSettings(settings) {
+        try {
+            // Validate and prepare settings for storage
+            const validatedSettings = this.validateSettings(settings);
+            if (this.repository) {
+                // Save all settings (including API keys) encrypted in database
+                this.repository.save('voice', validatedSettings);
+            }
+            else {
+                console.error('[VoiceSettingsManager] Repository not initialized, cannot save');
+                throw new Error('Settings repository not initialized');
+            }
+            this.cachedSettings = validatedSettings;
+            console.log('[VoiceSettingsManager] Settings saved to encrypted database');
+        }
+        catch (error) {
+            console.error('[VoiceSettingsManager] Failed to save settings:', error);
+            throw error;
+        }
+    }
+    /**
+     * Update partial settings
+     */
+    static updateSettings(partial) {
+        const current = this.loadSettings();
+        const updated = { ...current, ...partial };
+        this.saveSettings(updated);
+        return updated;
+    }
+    /**
+     * Clear cached settings
+     */
+    static clearCache() {
+        this.cachedSettings = null;
+    }
+    /**
+     * Delete all voice settings (reset to defaults)
+     */
+    static resetSettings() {
+        try {
+            if (this.repository) {
+                this.repository.delete('voice');
+            }
+            this.cachedSettings = null;
+            console.log('[VoiceSettingsManager] Settings reset to defaults');
+        }
+        catch (error) {
+            console.error('[VoiceSettingsManager] Failed to reset settings:', error);
+            throw error;
+        }
+    }
+    /**
+     * Check if ElevenLabs API key is configured
+     */
+    static hasElevenLabsKey() {
+        const settings = this.loadSettings();
+        return !!settings.elevenLabsApiKey;
+    }
+    /**
+     * Check if OpenAI API key is configured
+     */
+    static hasOpenAIKey() {
+        const settings = this.loadSettings();
+        return !!settings.openaiApiKey;
+    }
+    /**
+     * Check if Azure API key is configured
+     */
+    static hasAzureKey() {
+        const settings = this.loadSettings();
+        return !!settings.azureApiKey;
+    }
+    // ============ Migration from Legacy Files ============
+    /**
+     * Migrate settings from legacy JSON files to encrypted database
+     */
+    static migrateFromLegacyFiles() {
+        if (this.migrationComplete)
+            return;
+        if (!this.repository)
+            return;
+        const legacySettingsPath = path.join(this.userDataPath, LEGACY_SETTINGS_FILE);
+        const legacyKeysPath = path.join(this.userDataPath, LEGACY_SECURE_KEYS_FILE);
+        // Check if legacy files exist
+        const hasLegacySettings = fs.existsSync(legacySettingsPath);
+        const hasLegacyKeys = fs.existsSync(legacyKeysPath);
+        if (!hasLegacySettings && !hasLegacyKeys) {
+            this.migrationComplete = true;
+            return;
+        }
+        // Check if we already have settings in the database
+        if (this.repository.exists('voice')) {
+            // Clean up legacy files
+            this.cleanupLegacyFiles();
+            this.migrationComplete = true;
+            return;
+        }
+        console.log('[VoiceSettingsManager] Migrating from legacy JSON files to encrypted database...');
+        // Create backups before migration
+        const settingsBackupPath = legacySettingsPath + '.migration-backup';
+        const keysBackupPath = legacyKeysPath + '.migration-backup';
+        try {
+            if (hasLegacySettings) {
+                fs.copyFileSync(legacySettingsPath, settingsBackupPath);
+            }
+            if (hasLegacyKeys) {
+                fs.copyFileSync(legacyKeysPath, keysBackupPath);
+            }
+        }
+        catch (backupError) {
+            console.error('[VoiceSettingsManager] Failed to create backups:', backupError);
+            return;
+        }
+        try {
+            let settings = { ...types_1.DEFAULT_VOICE_SETTINGS };
+            // Load legacy settings file
+            if (hasLegacySettings) {
+                const data = fs.readFileSync(legacySettingsPath, 'utf-8');
+                const parsed = JSON.parse(data);
+                settings = {
+                    ...types_1.DEFAULT_VOICE_SETTINGS,
+                    ...parsed,
+                };
+                console.log('[VoiceSettingsManager] Loaded legacy settings file');
+            }
+            // Load legacy secure keys
+            if (hasLegacyKeys) {
+                const secureKeys = this.loadLegacySecureKeys(legacyKeysPath);
+                if (secureKeys.elevenLabsApiKey) {
+                    settings.elevenLabsApiKey = secureKeys.elevenLabsApiKey;
+                }
+                if (secureKeys.openaiApiKey) {
+                    settings.openaiApiKey = secureKeys.openaiApiKey;
+                }
+                if (secureKeys.azureApiKey) {
+                    settings.azureApiKey = secureKeys.azureApiKey;
+                }
+                console.log('[VoiceSettingsManager] Loaded legacy secure keys');
+            }
+            // Validate and save to database
+            settings = this.validateSettings(settings);
+            this.repository.save('voice', settings);
+            this.cachedSettings = settings;
+            console.log('[VoiceSettingsManager] Successfully migrated to encrypted database');
+            // Migration successful - delete backups and original files
+            if (hasLegacySettings) {
+                fs.unlinkSync(settingsBackupPath);
+                fs.unlinkSync(legacySettingsPath);
+            }
+            if (hasLegacyKeys) {
+                fs.unlinkSync(keysBackupPath);
+                fs.unlinkSync(legacyKeysPath);
+            }
+            console.log('[VoiceSettingsManager] Migration complete, cleaned up legacy files');
+            this.migrationComplete = true;
+        }
+        catch (error) {
+            console.error('[VoiceSettingsManager] Migration failed, backups preserved:', error);
+            if (hasLegacySettings) {
+                console.error('[VoiceSettingsManager] Settings backup at:', settingsBackupPath);
+            }
+            if (hasLegacyKeys) {
+                console.error('[VoiceSettingsManager] Keys backup at:', keysBackupPath);
+            }
+            // Don't throw - allow app to continue with defaults
+            this.migrationComplete = true;
+        }
+    }
+    /**
+     * Load secure keys from legacy encrypted file
+     */
+    static loadLegacySecureKeys(legacyKeysPath) {
+        try {
+            if (!electron_1.safeStorage.isEncryptionAvailable()) {
+                // Fall back to plain text storage if encryption unavailable
+                const data = fs.readFileSync(legacyKeysPath, 'utf-8');
+                return JSON.parse(data);
+            }
+            const encryptedData = fs.readFileSync(legacyKeysPath);
+            const decryptedString = electron_1.safeStorage.decryptString(encryptedData);
+            return JSON.parse(decryptedString);
+        }
+        catch (error) {
+            console.error('[VoiceSettingsManager] Failed to load legacy secure keys:', error);
+            return {};
+        }
+    }
+    /**
+     * Remove legacy files after successful migration
+     */
+    static cleanupLegacyFiles() {
+        const legacySettingsPath = path.join(this.userDataPath, LEGACY_SETTINGS_FILE);
+        const legacyKeysPath = path.join(this.userDataPath, LEGACY_SECURE_KEYS_FILE);
+        try {
+            if (fs.existsSync(legacySettingsPath)) {
+                // Rename to .bak instead of deleting (safety)
+                fs.renameSync(legacySettingsPath, legacySettingsPath + '.migrated');
+                console.log('[VoiceSettingsManager] Backed up legacy settings file');
+            }
+            if (fs.existsSync(legacyKeysPath)) {
+                // Securely delete encrypted keys file
+                fs.unlinkSync(legacyKeysPath);
+                console.log('[VoiceSettingsManager] Removed legacy secure keys file');
+            }
+        }
+        catch (error) {
+            console.warn('[VoiceSettingsManager] Failed to clean up legacy files:', error);
+            // Non-fatal - continue anyway
+        }
+    }
+    // ============ Validation ============
+    static validateSettings(settings) {
+        const validated = { ...settings };
+        // Validate provider
+        if (!['elevenlabs', 'openai', 'azure', 'local'].includes(validated.ttsProvider)) {
+            validated.ttsProvider = types_1.DEFAULT_VOICE_SETTINGS.ttsProvider;
+        }
+        if (!['elevenlabs', 'openai', 'azure', 'local'].includes(validated.sttProvider)) {
+            validated.sttProvider = types_1.DEFAULT_VOICE_SETTINGS.sttProvider;
+        }
+        // Validate input mode
+        if (!['push_to_talk', 'voice_activity', 'disabled'].includes(validated.inputMode)) {
+            validated.inputMode = types_1.DEFAULT_VOICE_SETTINGS.inputMode;
+        }
+        // Validate response mode
+        if (!['auto', 'manual', 'smart'].includes(validated.responseMode)) {
+            validated.responseMode = types_1.DEFAULT_VOICE_SETTINGS.responseMode;
+        }
+        // Validate OpenAI and Azure voices
+        const validVoices = ['alloy', 'echo', 'fable', 'onyx', 'nova', 'shimmer'];
+        if (validated.openaiVoice && !validVoices.includes(validated.openaiVoice)) {
+            validated.openaiVoice = undefined;
+        }
+        if (validated.azureVoice && !validVoices.includes(validated.azureVoice)) {
+            validated.azureVoice = undefined;
+        }
+        // Validate numeric ranges
+        validated.volume = Math.max(0, Math.min(100, validated.volume || types_1.DEFAULT_VOICE_SETTINGS.volume));
+        validated.speechRate = Math.max(0.5, Math.min(2.0, validated.speechRate || types_1.DEFAULT_VOICE_SETTINGS.speechRate));
+        validated.silenceTimeout = Math.max(1, Math.min(10, validated.silenceTimeout || types_1.DEFAULT_VOICE_SETTINGS.silenceTimeout));
+        return validated;
+    }
+}
+exports.VoiceSettingsManager = VoiceSettingsManager;
+VoiceSettingsManager.repository = null;
+VoiceSettingsManager.cachedSettings = null;
+VoiceSettingsManager.migrationComplete = false;

package/dist/electron/shared/channelMessages.js

@@ -0,0 +1,170 @@
+"use strict";
+/**
+ * Channel Message Templates
+ *
+ * Personality-based message templates for messaging channels (Telegram, WhatsApp, Slack, etc.)
+ * These messages are used when sending task status updates to external channels.
+ *
+ * This file is in shared/ so it can be used by both the main process (gateway) and renderer.
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.DEFAULT_CHANNEL_CONTEXT = void 0;
+exports.getChannelMessage = getChannelMessage;
+exports.getCompletionMessage = getCompletionMessage;
+/**
+ * Message templates organized by personality type
+ */
+const CHANNEL_MESSAGES = {
+    professional: {
+        taskComplete: 'Complete.',
+        taskCompleteWithResult: 'Complete.\n\n{result}',
+        taskFailed: 'Task failed: {error}',
+        toolError: 'Tool error ({tool}): {error}',
+        followUpProcessed: 'Follow-up processed.',
+        followUpFailed: 'Follow-up failed: {error}',
+        approvalNeeded: 'Approval required.',
+    },
+    friendly: {
+        taskComplete: 'Done! Nice work.',
+        taskCompleteWithResult: 'Done!\n\n{result}',
+        taskFailed: 'Oops, something went wrong: {error}',
+        toolError: 'Hit a snag with {tool}: {error}',
+        followUpProcessed: 'Got it!',
+        followUpFailed: 'That follow-up hit a bump: {error}',
+        approvalNeeded: 'Need your OK on this!',
+    },
+    concise: {
+        taskComplete: 'Done.',
+        taskCompleteWithResult: 'Done.\n\n{result}',
+        taskFailed: 'Failed: {error}',
+        toolError: '{tool} error: {error}',
+        followUpProcessed: 'Done.',
+        followUpFailed: 'Failed: {error}',
+        approvalNeeded: 'Approval?',
+    },
+    creative: {
+        taskComplete: 'Masterpiece complete.',
+        taskCompleteWithResult: 'Masterpiece complete.\n\n{result}',
+        taskFailed: 'A twist in the tale: {error}',
+        toolError: '{tool} encountered a plot twist: {error}',
+        followUpProcessed: 'Another piece falls into place.',
+        followUpFailed: 'The sequel hit a snag: {error}',
+        approvalNeeded: 'Your vision is needed.',
+    },
+    technical: {
+        taskComplete: 'Execution complete.',
+        taskCompleteWithResult: 'Execution complete.\n\n{result}',
+        taskFailed: 'Error: {error}',
+        toolError: '{tool} exception: {error}',
+        followUpProcessed: 'Follow-up executed.',
+        followUpFailed: 'Follow-up exception: {error}',
+        approvalNeeded: 'Awaiting user input.',
+    },
+    casual: {
+        taskComplete: 'Nailed it.',
+        taskCompleteWithResult: 'Nailed it.\n\n{result}',
+        taskFailed: 'Uh oh: {error}',
+        toolError: '{tool} had a moment: {error}',
+        followUpProcessed: 'Check.',
+        followUpFailed: 'That didn\'t work: {error}',
+        approvalNeeded: 'Your call.',
+    },
+    custom: {
+        taskComplete: 'Done.',
+        taskCompleteWithResult: 'Done.\n\n{result}',
+        taskFailed: 'Task failed: {error}',
+        toolError: 'Tool error ({tool}): {error}',
+        followUpProcessed: 'Follow-up complete.',
+        followUpFailed: 'Follow-up failed: {error}',
+        approvalNeeded: 'Approval needed.',
+    },
+};
+/**
+ * Emoji mappings for message types
+ */
+const EMOJI_MAP = {
+    taskComplete: '✓',
+    taskCompleteWithResult: '✓',
+    taskFailed: '✗',
+    toolError: '⚠',
+    followUpProcessed: '✓',
+    followUpFailed: '✗',
+    approvalNeeded: '❓',
+};
+/**
+ * Add emoji based on emojiUsage setting
+ */
+function addEmoji(message, key, emojiUsage) {
+    if (emojiUsage === 'none')
+        return message;
+    const emoji = EMOJI_MAP[key];
+    if (!emoji)
+        return message;
+    // For minimal, only add checkmarks for success
+    if (emojiUsage === 'minimal' && !['taskComplete', 'taskCompleteWithResult', 'followUpProcessed'].includes(key)) {
+        return message;
+    }
+    return `${emoji} ${message}`;
+}
+/**
+ * Get a personalized channel message
+ */
+function getChannelMessage(key, ctx, replacements) {
+    const { personality, emojiUsage, quirks } = ctx;
+    // Get base message for personality
+    const messages = CHANNEL_MESSAGES[personality] || CHANNEL_MESSAGES.professional;
+    let message = messages[key] || CHANNEL_MESSAGES.professional[key] || key;
+    // Replace placeholders
+    if (replacements) {
+        for (const [placeholder, value] of Object.entries(replacements)) {
+            message = message.replace(`{${placeholder}}`, value);
+        }
+    }
+    // Add emoji if appropriate
+    message = addEmoji(message, key, emojiUsage);
+    // Add sign-off to completion messages
+    if ((key === 'taskComplete' || key === 'taskCompleteWithResult') && quirks.signOff) {
+        message = `${message}\n\n${quirks.signOff}`;
+    }
+    return message;
+}
+/**
+ * Get completion message with optional result and follow-up hint
+ * This is specific to channel messages which may include additional hints
+ */
+function getCompletionMessage(ctx, result, includeFollowUpHint = true) {
+    const key = result ? 'taskCompleteWithResult' : 'taskComplete';
+    let message = getChannelMessage(key, ctx, result ? { result } : undefined);
+    // Add follow-up hint for channels that support it
+    if (includeFollowUpHint && ctx.personality !== 'concise') {
+        const hints = {
+            professional: 'Send a follow-up message to continue, or use /newtask to start fresh.',
+            friendly: 'Got more to do? Just send another message!',
+            concise: '',
+            creative: 'The story continues... send your next chapter!',
+            technical: 'Ready for next command. Use /newtask for new context.',
+            casual: 'What\'s next? Just hit me up.',
+            custom: 'Send a follow-up message to continue.',
+        };
+        const hint = hints[ctx.personality];
+        if (hint) {
+            message = `${message}\n\n${hint}`;
+        }
+    }
+    return message;
+}
+/**
+ * Default message context using professional personality
+ */
+exports.DEFAULT_CHANNEL_CONTEXT = {
+    agentName: 'CoWork',
+    userName: undefined,
+    personality: 'professional',
+    emojiUsage: 'minimal',
+    quirks: {
+        catchphrase: undefined,
+        signOff: undefined,
+        analogyDomain: 'none',
+    },
+};
+exports.default = getChannelMessage;