cowork-os 0.3.21

package/dist/electron/electron/tray/index.js

@@ -0,0 +1,9 @@
+"use strict";
+/**
+ * Tray Module - macOS Menu Bar Integration
+ */
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.trayManager = exports.TrayManager = void 0;
+var TrayManager_1 = require("./TrayManager");
+Object.defineProperty(exports, "TrayManager", { enumerable: true, get: function () { return TrayManager_1.TrayManager; } });
+Object.defineProperty(exports, "trayManager", { enumerable: true, get: function () { return TrayManager_1.trayManager; } });

package/dist/electron/electron/updater/index.js

@@ -0,0 +1,6 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.updateManager = exports.UpdateManager = void 0;
+var update_manager_1 = require("./update-manager");
+Object.defineProperty(exports, "UpdateManager", { enumerable: true, get: function () { return update_manager_1.UpdateManager; } });
+Object.defineProperty(exports, "updateManager", { enumerable: true, get: function () { return update_manager_1.updateManager; } });

package/dist/electron/electron/updater/update-manager.js

@@ -0,0 +1,418 @@
+"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.updateManager = exports.UpdateManager = void 0;
+const electron_1 = require("electron");
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const types_1 = require("../../shared/types");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+class UpdateManager {
+    constructor() {
+        this.mainWindow = null;
+        this.repoOwner = 'CoWork-OS';
+        this.repoName = 'cowork-os';
+        this.isUpdating = false;
+    }
+    setMainWindow(window) {
+        this.mainWindow = window;
+    }
+    sendProgress(progress) {
+        if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+            this.mainWindow.webContents.send(types_1.IPC_CHANNELS.APP_UPDATE_PROGRESS, progress);
+        }
+    }
+    sendError(error) {
+        if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+            this.mainWindow.webContents.send(types_1.IPC_CHANNELS.APP_UPDATE_ERROR, { error });
+        }
+    }
+    async getVersionInfo() {
+        const version = electron_1.app.getVersion();
+        const isDev = !electron_1.app.isPackaged;
+        let isGitRepo = false;
+        let isNpmGlobal = false;
+        let gitBranch;
+        let gitCommit;
+        const appPath = electron_1.app.getAppPath();
+        // Check if installed via npm global
+        isNpmGlobal = this.detectNpmGlobalInstall(appPath);
+        if (isDev && !isNpmGlobal) {
+            try {
+                const { stdout: branchOut } = await execAsync('git rev-parse --abbrev-ref HEAD', { cwd: appPath });
+                gitBranch = branchOut.trim();
+                const { stdout: commitOut } = await execAsync('git rev-parse --short HEAD', { cwd: appPath });
+                gitCommit = commitOut.trim();
+                isGitRepo = true;
+            }
+            catch {
+                isGitRepo = false;
+            }
+        }
+        return {
+            version,
+            isDev,
+            isGitRepo,
+            isNpmGlobal,
+            gitBranch,
+            gitCommit,
+        };
+    }
+    detectNpmGlobalInstall(appPath) {
+        // Check common npm global installation paths
+        const npmGlobalPatterns = [
+            '/usr/local/lib/node_modules',
+            '/usr/lib/node_modules',
+            '/opt/homebrew/lib/node_modules',
+            'node_modules/cowork-os',
+            '.nvm/versions/node',
+            '.npm-global',
+            'AppData/Roaming/npm/node_modules', // Windows
+        ];
+        const normalizedPath = appPath.replace(/\\/g, '/');
+        return npmGlobalPatterns.some(pattern => normalizedPath.includes(pattern));
+    }
+    async checkForUpdates() {
+        const versionInfo = await this.getVersionInfo();
+        const currentVersion = versionInfo.version;
+        this.sendProgress({ phase: 'checking', message: 'Checking for updates...' });
+        try {
+            // Fetch latest release from GitHub
+            const response = await fetch(`https://api.github.com/repos/${this.repoOwner}/${this.repoName}/releases/latest`, {
+                headers: {
+                    'Accept': 'application/vnd.github.v3+json',
+                    'User-Agent': 'CoWork-OS-Updater',
+                },
+            });
+            if (!response.ok) {
+                if (response.status === 404) {
+                    return {
+                        available: false,
+                        currentVersion,
+                        latestVersion: currentVersion,
+                        updateMode: this.getUpdateMode(versionInfo),
+                    };
+                }
+                throw new Error(`GitHub API error: ${response.status}`);
+            }
+            const release = await response.json();
+            const latestVersion = release.tag_name.replace(/^v/, '');
+            const available = this.isNewerVersion(latestVersion, currentVersion);
+            // Determine update mode based on installation type
+            const updateMode = this.getUpdateMode(versionInfo);
+            if (versionInfo.isGitRepo && !available) {
+                // Only check for new commits if versions are equal (not if local version is newer)
+                const localIsNewer = this.isNewerVersion(currentVersion, latestVersion);
+                if (!localIsNewer) {
+                    // Check for new commits even if version tag is same
+                    const hasNewCommits = await this.checkForNewCommits();
+                    if (hasNewCommits) {
+                        return {
+                            available: true,
+                            currentVersion: `${currentVersion} (${versionInfo.gitCommit})`,
+                            latestVersion: `${latestVersion} (new commits)`,
+                            releaseNotes: 'New commits available on the main branch.',
+                            releaseUrl: `https://github.com/${this.repoOwner}/${this.repoName}`,
+                            updateMode: 'git',
+                        };
+                    }
+                }
+            }
+            return {
+                available,
+                currentVersion,
+                latestVersion,
+                releaseNotes: release.body,
+                releaseUrl: release.html_url,
+                publishedAt: release.published_at,
+                updateMode,
+            };
+        }
+        catch (error) {
+            this.sendError(error.message);
+            throw error;
+        }
+    }
+    async checkForNewCommits() {
+        try {
+            const appPath = electron_1.app.getAppPath();
+            // Fetch latest from remote
+            await execAsync('git fetch origin', { cwd: appPath });
+            // Check if there are commits ahead on remote
+            const { stdout } = await execAsync('git rev-list HEAD..origin/main --count', { cwd: appPath });
+            const commitsAhead = parseInt(stdout.trim(), 10);
+            return commitsAhead > 0;
+        }
+        catch {
+            return false;
+        }
+    }
+    isNewerVersion(latest, current) {
+        // Normalize versions: convert "0.3.9-1" to "0.3.9.1" for comparison
+        const normalizeVersion = (v) => {
+            // Replace hyphens with dots for consistent parsing
+            const normalized = v.replace(/-/g, '.');
+            return normalized.split('.').map(n => parseInt(n, 10) || 0);
+        };
+        const latestParts = normalizeVersion(latest);
+        const currentParts = normalizeVersion(current);
+        for (let i = 0; i < Math.max(latestParts.length, currentParts.length); i++) {
+            const l = latestParts[i] || 0;
+            const c = currentParts[i] || 0;
+            if (l > c)
+                return true;
+            if (l < c)
+                return false;
+        }
+        return false;
+    }
+    getUpdateMode(versionInfo) {
+        if (versionInfo.isNpmGlobal) {
+            return 'npm';
+        }
+        if (versionInfo.isGitRepo) {
+            return 'git';
+        }
+        return 'electron-updater';
+    }
+    async downloadAndInstallUpdate(updateInfo) {
+        if (this.isUpdating) {
+            throw new Error('Update already in progress');
+        }
+        this.isUpdating = true;
+        try {
+            if (updateInfo.updateMode === 'npm') {
+                await this.npmUpdate();
+            }
+            else if (updateInfo.updateMode === 'git') {
+                await this.gitUpdate();
+            }
+            else {
+                await this.electronUpdaterUpdate();
+            }
+        }
+        finally {
+            this.isUpdating = false;
+        }
+    }
+    async gitUpdate() {
+        const appPath = electron_1.app.getAppPath();
+        try {
+            // Step 1: Stash any local changes
+            this.sendProgress({ phase: 'downloading', percent: 10, message: 'Stashing local changes...' });
+            try {
+                await execAsync('git stash', { cwd: appPath });
+            }
+            catch {
+                // Ignore if nothing to stash
+            }
+            // Step 2: Fetch and pull latest
+            this.sendProgress({ phase: 'downloading', percent: 30, message: 'Pulling latest changes from GitHub...' });
+            await execAsync('git fetch origin', { cwd: appPath });
+            await execAsync('git pull origin main', { cwd: appPath });
+            // Step 3: Install dependencies
+            this.sendProgress({ phase: 'installing', percent: 50, message: 'Installing dependencies (npm install)...' });
+            await this.runNpmInstall(appPath);
+            // Step 4: Rebuild
+            this.sendProgress({ phase: 'installing', percent: 80, message: 'Building application (npm run build)...' });
+            await this.runNpmBuild(appPath);
+            // Step 5: Complete
+            this.sendProgress({ phase: 'complete', percent: 100, message: 'Update complete! Please restart the application.' });
+            if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+                this.mainWindow.webContents.send(types_1.IPC_CHANNELS.APP_UPDATE_DOWNLOADED, {
+                    requiresRestart: true,
+                    message: 'Update complete! Please restart the application to apply changes.',
+                });
+            }
+        }
+        catch (error) {
+            this.sendProgress({ phase: 'error', message: `Update failed: ${error.message}` });
+            this.sendError(error.message);
+            throw error;
+        }
+    }
+    async npmUpdate() {
+        try {
+            // Step 1: Run npm update
+            this.sendProgress({ phase: 'downloading', percent: 20, message: 'Updating via npm...' });
+            await this.runNpmGlobalUpdate();
+            // Step 2: Complete
+            this.sendProgress({ phase: 'complete', percent: 100, message: 'Update complete! Please restart the application.' });
+            if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+                this.mainWindow.webContents.send(types_1.IPC_CHANNELS.APP_UPDATE_DOWNLOADED, {
+                    requiresRestart: true,
+                    message: 'Update complete! Please restart the application to apply changes.',
+                });
+            }
+        }
+        catch (error) {
+            this.sendProgress({ phase: 'error', message: `Update failed: ${error.message}` });
+            this.sendError(error.message);
+            throw error;
+        }
+    }
+    runNpmGlobalUpdate() {
+        return new Promise((resolve, reject) => {
+            const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+            const child = (0, child_process_1.spawn)(npm, ['install', '-g', 'cowork-os@latest'], { shell: true });
+            let stderr = '';
+            child.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`npm update failed with code ${code}: ${stderr}`));
+                }
+            });
+            child.on('error', reject);
+        });
+    }
+    runNpmInstall(cwd) {
+        return new Promise((resolve, reject) => {
+            const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+            const child = (0, child_process_1.spawn)(npm, ['install'], { cwd, shell: true });
+            let stderr = '';
+            child.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`npm install failed with code ${code}: ${stderr}`));
+                }
+            });
+            child.on('error', reject);
+        });
+    }
+    runNpmBuild(cwd) {
+        return new Promise((resolve, reject) => {
+            const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+            const child = (0, child_process_1.spawn)(npm, ['run', 'build'], { cwd, shell: true });
+            let stderr = '';
+            child.stderr.on('data', (data) => {
+                stderr += data.toString();
+            });
+            child.on('close', (code) => {
+                if (code === 0) {
+                    resolve();
+                }
+                else {
+                    reject(new Error(`npm run build failed with code ${code}: ${stderr}`));
+                }
+            });
+            child.on('error', reject);
+        });
+    }
+    async electronUpdaterUpdate() {
+        // For packaged apps, we'll use electron-updater
+        // This requires electron-updater to be installed and configured
+        try {
+            // Dynamic import to avoid issues when running in dev mode
+            const electronUpdater = await Promise.resolve().then(() => __importStar(require('electron-updater'))).catch(() => null);
+            if (!electronUpdater) {
+                throw new Error('electron-updater not available');
+            }
+            const { autoUpdater } = electronUpdater;
+            autoUpdater.on('checking-for-update', () => {
+                this.sendProgress({ phase: 'checking', message: 'Checking for updates...' });
+            });
+            autoUpdater.on('update-available', () => {
+                this.sendProgress({ phase: 'downloading', percent: 0, message: 'Update available, starting download...' });
+            });
+            autoUpdater.on('download-progress', (progress) => {
+                this.sendProgress({
+                    phase: 'downloading',
+                    percent: Math.round(progress.percent),
+                    message: `Downloading update... ${Math.round(progress.percent)}%`,
+                    bytesDownloaded: progress.transferred,
+                    bytesTotal: progress.total,
+                });
+            });
+            autoUpdater.on('update-downloaded', () => {
+                this.sendProgress({ phase: 'complete', percent: 100, message: 'Update downloaded. Ready to install.' });
+                if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+                    this.mainWindow.webContents.send(types_1.IPC_CHANNELS.APP_UPDATE_DOWNLOADED, {
+                        requiresRestart: true,
+                        message: 'Update downloaded. Click "Install & Restart" to apply.',
+                    });
+                }
+            });
+            autoUpdater.on('error', (error) => {
+                this.sendProgress({ phase: 'error', message: `Update error: ${error.message}` });
+                this.sendError(error.message);
+            });
+            await autoUpdater.downloadUpdate();
+        }
+        catch (error) {
+            // If electron-updater is not available, fall back to manual download
+            this.sendProgress({ phase: 'error', message: 'electron-updater not available. Please download manually from GitHub.' });
+            throw new Error('Auto-update not available for packaged builds. Please download the latest release from GitHub.');
+        }
+    }
+    async installUpdateAndRestart() {
+        const versionInfo = await this.getVersionInfo();
+        if (versionInfo.isGitRepo) {
+            // For git-based updates, just restart the app
+            electron_1.app.relaunch();
+            electron_1.app.exit(0);
+        }
+        else {
+            // For electron-updater, quit and install
+            try {
+                const electronUpdater = await Promise.resolve().then(() => __importStar(require('electron-updater'))).catch(() => null);
+                if (electronUpdater) {
+                    electronUpdater.autoUpdater.quitAndInstall();
+                }
+                else {
+                    // Fallback: just restart
+                    electron_1.app.relaunch();
+                    electron_1.app.exit(0);
+                }
+            }
+            catch {
+                // Fallback: just restart
+                electron_1.app.relaunch();
+                electron_1.app.exit(0);
+            }
+        }
+    }
+}
+exports.UpdateManager = UpdateManager;
+exports.updateManager = new UpdateManager();

package/dist/electron/electron/utils/env-migration.js

@@ -0,0 +1,209 @@
+"use strict";
+/**
+ * Migration utility for users upgrading from .env-based configuration
+ * to GUI Settings with secure storage.
+ *
+ * This runs once on app startup and:
+ * 1. Detects if a .env file exists in the app directory
+ * 2. Reads any configured credentials
+ * 3. Migrates them to the new Settings system (with safeStorage encryption)
+ * 4. Renames the .env file to .env.migrated to prevent re-migration
+ * 5. Returns a summary for the user notification
+ */
+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.migrateEnvToSettings = migrateEnvToSettings;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const electron_1 = require("electron");
+const llm_1 = require("../agent/llm");
+const search_1 = require("../agent/search");
+/**
+ * Parse a .env file into key-value pairs
+ */
+function parseEnvFile(content) {
+    const result = {};
+    const lines = content.split('\n');
+    for (const line of lines) {
+        // Skip empty lines and comments
+        const trimmed = line.trim();
+        if (!trimmed || trimmed.startsWith('#'))
+            continue;
+        // Parse KEY=VALUE (handle quoted values)
+        const eqIndex = trimmed.indexOf('=');
+        if (eqIndex === -1)
+            continue;
+        const key = trimmed.slice(0, eqIndex).trim();
+        let value = trimmed.slice(eqIndex + 1).trim();
+        // Remove surrounding quotes if present
+        if ((value.startsWith('"') && value.endsWith('"')) ||
+            (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        if (key && value) {
+            result[key] = value;
+        }
+    }
+    return result;
+}
+/**
+ * Check for and migrate .env configuration to Settings
+ */
+async function migrateEnvToSettings() {
+    const migratedKeys = [];
+    // Check multiple possible locations for .env
+    const possiblePaths = [
+        path.join(electron_1.app.getAppPath(), '.env'),
+        path.join(process.cwd(), '.env'),
+        path.join(electron_1.app.getPath('userData'), '.env'),
+    ];
+    let envPath = null;
+    let envContent = null;
+    for (const p of possiblePaths) {
+        try {
+            if (fs.existsSync(p)) {
+                envContent = fs.readFileSync(p, 'utf-8');
+                envPath = p;
+                break;
+            }
+        }
+        catch {
+            // Ignore read errors, try next path
+        }
+    }
+    if (!envPath || !envContent) {
+        return { migrated: false, migratedKeys: [] };
+    }
+    // Check if already migrated
+    const migratedPath = envPath + '.migrated';
+    if (fs.existsSync(migratedPath)) {
+        return { migrated: false, migratedKeys: [] };
+    }
+    try {
+        const env = parseEnvFile(envContent);
+        // Load current settings
+        const llmSettings = llm_1.LLMProviderFactory.loadSettings();
+        const searchSettings = search_1.SearchProviderFactory.loadSettings();
+        let llmChanged = false;
+        let searchChanged = false;
+        // Migrate Anthropic API key
+        if (env.ANTHROPIC_API_KEY && !llmSettings.anthropic?.apiKey) {
+            llmSettings.anthropic = { ...llmSettings.anthropic, apiKey: env.ANTHROPIC_API_KEY };
+            migratedKeys.push('Anthropic API Key');
+            llmChanged = true;
+        }
+        // Migrate AWS Bedrock credentials
+        if (env.AWS_ACCESS_KEY_ID && !llmSettings.bedrock?.accessKeyId) {
+            llmSettings.bedrock = {
+                ...llmSettings.bedrock,
+                accessKeyId: env.AWS_ACCESS_KEY_ID,
+                secretAccessKey: env.AWS_SECRET_ACCESS_KEY,
+                sessionToken: env.AWS_SESSION_TOKEN,
+                region: env.AWS_REGION || env.AWS_DEFAULT_REGION,
+                profile: env.AWS_PROFILE,
+            };
+            migratedKeys.push('AWS Bedrock Credentials');
+            llmChanged = true;
+        }
+        // Migrate Gemini API key
+        if (env.GEMINI_API_KEY && !llmSettings.gemini?.apiKey) {
+            llmSettings.gemini = { ...llmSettings.gemini, apiKey: env.GEMINI_API_KEY };
+            migratedKeys.push('Gemini API Key');
+            llmChanged = true;
+        }
+        // Migrate OpenRouter API key
+        if (env.OPENROUTER_API_KEY && !llmSettings.openrouter?.apiKey) {
+            llmSettings.openrouter = { ...llmSettings.openrouter, apiKey: env.OPENROUTER_API_KEY };
+            migratedKeys.push('OpenRouter API Key');
+            llmChanged = true;
+        }
+        // Migrate Ollama settings
+        if (env.OLLAMA_BASE_URL && !llmSettings.ollama?.baseUrl) {
+            llmSettings.ollama = {
+                ...llmSettings.ollama,
+                baseUrl: env.OLLAMA_BASE_URL,
+                apiKey: env.OLLAMA_API_KEY,
+            };
+            migratedKeys.push('Ollama Configuration');
+            llmChanged = true;
+        }
+        // Migrate Search API keys
+        if (env.TAVILY_API_KEY && !searchSettings.tavily?.apiKey) {
+            searchSettings.tavily = { apiKey: env.TAVILY_API_KEY };
+            migratedKeys.push('Tavily API Key');
+            searchChanged = true;
+        }
+        if (env.BRAVE_API_KEY && !searchSettings.brave?.apiKey) {
+            searchSettings.brave = { apiKey: env.BRAVE_API_KEY };
+            migratedKeys.push('Brave Search API Key');
+            searchChanged = true;
+        }
+        if (env.SERPAPI_API_KEY && !searchSettings.serpapi?.apiKey) {
+            searchSettings.serpapi = { apiKey: env.SERPAPI_API_KEY };
+            migratedKeys.push('SerpAPI Key');
+            searchChanged = true;
+        }
+        if (env.GOOGLE_API_KEY && !searchSettings.google?.apiKey) {
+            searchSettings.google = {
+                apiKey: env.GOOGLE_API_KEY,
+                searchEngineId: env.GOOGLE_SEARCH_ENGINE_ID,
+            };
+            migratedKeys.push('Google Search API Key');
+            searchChanged = true;
+        }
+        // Save migrated settings
+        if (llmChanged) {
+            llm_1.LLMProviderFactory.saveSettings(llmSettings);
+        }
+        if (searchChanged) {
+            search_1.SearchProviderFactory.saveSettings(searchSettings);
+        }
+        // Rename .env to .env.migrated to prevent re-migration
+        if (migratedKeys.length > 0) {
+            fs.renameSync(envPath, migratedPath);
+        }
+        return {
+            migrated: migratedKeys.length > 0,
+            migratedKeys,
+        };
+    }
+    catch (error) {
+        return {
+            migrated: false,
+            migratedKeys: [],
+            error: error.message,
+        };
+    }
+}