cowork-os 0.3.21

package/src/electron/tray/index.ts

@@ -0,0 +1,6 @@
+/**
+ * Tray Module - macOS Menu Bar Integration
+ */
+
+export { TrayManager, trayManager } from './TrayManager';
+export type { TraySettings, TrayManagerOptions } from './TrayManager';

package/src/electron/updater/index.ts

@@ -0,0 +1 @@
+export { UpdateManager, updateManager } from './update-manager';

package/src/electron/updater/update-manager.ts

@@ -0,0 +1,447 @@
+import { app, BrowserWindow } from 'electron';
+import { exec, spawn } from 'child_process';
+import { promisify } from 'util';
+import * as path from 'path';
+import * as fs from 'fs';
+import { UpdateInfo, UpdateProgress, AppVersionInfo, IPC_CHANNELS } from '../../shared/types';
+
+const execAsync = promisify(exec);
+
+interface GitHubRelease {
+  tag_name: string;
+  name: string;
+  body: string;
+  html_url: string;
+  published_at: string;
+  assets: Array<{
+    name: string;
+    browser_download_url: string;
+    size: number;
+  }>;
+}
+
+export class UpdateManager {
+  private mainWindow: BrowserWindow | null = null;
+  private repoOwner = 'CoWork-OS';
+  private repoName = 'cowork-os';
+  private isUpdating = false;
+
+  setMainWindow(window: BrowserWindow): void {
+    this.mainWindow = window;
+  }
+
+  private sendProgress(progress: UpdateProgress): void {
+    if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+      this.mainWindow.webContents.send(IPC_CHANNELS.APP_UPDATE_PROGRESS, progress);
+    }
+  }
+
+  private sendError(error: string): void {
+    if (this.mainWindow && !this.mainWindow.isDestroyed()) {
+      this.mainWindow.webContents.send(IPC_CHANNELS.APP_UPDATE_ERROR, { error });
+    }
+  }
+
+  async getVersionInfo(): Promise<AppVersionInfo> {
+    const version = app.getVersion();
+    const isDev = !app.isPackaged;
+    let isGitRepo = false;
+    let isNpmGlobal = false;
+    let gitBranch: string | undefined;
+    let gitCommit: string | undefined;
+
+    const appPath = 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,
+    };
+  }
+
+  private detectNpmGlobalInstall(appPath: string): boolean {
+    // 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(): Promise<UpdateInfo> {
+    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() as GitHubRelease;
+      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: any) {
+      this.sendError(error.message);
+      throw error;
+    }
+  }
+
+  private async checkForNewCommits(): Promise<boolean> {
+    try {
+      const appPath = 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;
+    }
+  }
+
+  private isNewerVersion(latest: string, current: string): boolean {
+    // Normalize versions: convert "0.3.9-1" to "0.3.9.1" for comparison
+    const normalizeVersion = (v: string): number[] => {
+      // 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;
+  }
+
+  private getUpdateMode(versionInfo: AppVersionInfo): 'git' | 'npm' | 'electron-updater' {
+    if (versionInfo.isNpmGlobal) {
+      return 'npm';
+    }
+    if (versionInfo.isGitRepo) {
+      return 'git';
+    }
+    return 'electron-updater';
+  }
+
+  async downloadAndInstallUpdate(updateInfo: UpdateInfo): Promise<void> {
+    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;
+    }
+  }
+
+  private async gitUpdate(): Promise<void> {
+    const appPath = 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(IPC_CHANNELS.APP_UPDATE_DOWNLOADED, {
+          requiresRestart: true,
+          message: 'Update complete! Please restart the application to apply changes.',
+        });
+      }
+    } catch (error: any) {
+      this.sendProgress({ phase: 'error', message: `Update failed: ${error.message}` });
+      this.sendError(error.message);
+      throw error;
+    }
+  }
+
+  private async npmUpdate(): Promise<void> {
+    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(IPC_CHANNELS.APP_UPDATE_DOWNLOADED, {
+          requiresRestart: true,
+          message: 'Update complete! Please restart the application to apply changes.',
+        });
+      }
+    } catch (error: any) {
+      this.sendProgress({ phase: 'error', message: `Update failed: ${error.message}` });
+      this.sendError(error.message);
+      throw error;
+    }
+  }
+
+  private runNpmGlobalUpdate(): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+      const child = 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);
+    });
+  }
+
+  private runNpmInstall(cwd: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+      const child = 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);
+    });
+  }
+
+  private runNpmBuild(cwd: string): Promise<void> {
+    return new Promise((resolve, reject) => {
+      const npm = process.platform === 'win32' ? 'npm.cmd' : 'npm';
+      const child = 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);
+    });
+  }
+
+  private async electronUpdaterUpdate(): Promise<void> {
+    // 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 import('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: { percent: number; transferred: number; total: number }) => {
+        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(IPC_CHANNELS.APP_UPDATE_DOWNLOADED, {
+            requiresRestart: true,
+            message: 'Update downloaded. Click "Install & Restart" to apply.',
+          });
+        }
+      });
+
+      autoUpdater.on('error', (error: Error) => {
+        this.sendProgress({ phase: 'error', message: `Update error: ${error.message}` });
+        this.sendError(error.message);
+      });
+
+      await autoUpdater.downloadUpdate();
+    } catch (error: any) {
+      // 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(): Promise<void> {
+    const versionInfo = await this.getVersionInfo();
+
+    if (versionInfo.isGitRepo) {
+      // For git-based updates, just restart the app
+      app.relaunch();
+      app.exit(0);
+    } else {
+      // For electron-updater, quit and install
+      try {
+        const electronUpdater = await import('electron-updater').catch(() => null);
+        if (electronUpdater) {
+          electronUpdater.autoUpdater.quitAndInstall();
+        } else {
+          // Fallback: just restart
+          app.relaunch();
+          app.exit(0);
+        }
+      } catch {
+        // Fallback: just restart
+        app.relaunch();
+        app.exit(0);
+      }
+    }
+  }
+}
+
+export const updateManager = new UpdateManager();

package/src/electron/utils/env-migration.ts

@@ -0,0 +1,203 @@
+/**
+ * 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
+ */
+
+import * as fs from 'fs';
+import * as path from 'path';
+import { app } from 'electron';
+import { LLMProviderFactory } from '../agent/llm';
+import { SearchProviderFactory } from '../agent/search';
+
+interface MigrationResult {
+  migrated: boolean;
+  migratedKeys: string[];
+  error?: string;
+}
+
+/**
+ * Parse a .env file into key-value pairs
+ */
+function parseEnvFile(content: string): Record<string, string> {
+  const result: Record<string, string> = {};
+  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
+ */
+export async function migrateEnvToSettings(): Promise<MigrationResult> {
+  const migratedKeys: string[] = [];
+
+  // Check multiple possible locations for .env
+  const possiblePaths = [
+    path.join(app.getAppPath(), '.env'),
+    path.join(process.cwd(), '.env'),
+    path.join(app.getPath('userData'), '.env'),
+  ];
+
+  let envPath: string | null = null;
+  let envContent: string | null = 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 = LLMProviderFactory.loadSettings();
+    const searchSettings = 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) {
+      LLMProviderFactory.saveSettings(llmSettings);
+    }
+    if (searchChanged) {
+      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: any) {
+    return {
+      migrated: false,
+      migratedKeys: [],
+      error: error.message,
+    };
+  }
+}