cowork-os 0.3.21

package/dist/electron/electron/tray/TrayManager.js

@@ -0,0 +1,895 @@
+"use strict";
+/**
+ * TrayManager - macOS Menu Bar App Integration
+ *
+ * Provides a native menu bar icon with:
+ * - Status indicator (connected/disconnected channels)
+ * - Quick actions menu (new task, workspaces, settings)
+ * - Show/hide main window on click
+ * - Gateway status monitoring
+ *
+ * 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.trayManager = exports.TrayManager = void 0;
+const electron_1 = require("electron");
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const fs = __importStar(require("fs"));
+const repositories_1 = require("../database/repositories");
+const QuickInputWindow_1 = require("./QuickInputWindow");
+const types_1 = require("../../shared/types");
+const SecureSettingsRepository_1 = require("../database/SecureSettingsRepository");
+const LEGACY_SETTINGS_FILE = 'tray-settings.json';
+const DEFAULT_SETTINGS = {
+    enabled: true,
+    showDockIcon: true,
+    startMinimized: false,
+    closeToTray: true,
+    showNotifications: true,
+};
+class TrayManager {
+    static getInstance() {
+        if (!TrayManager.instance) {
+            TrayManager.instance = new TrayManager();
+        }
+        return TrayManager.instance;
+    }
+    constructor() {
+        this.tray = null;
+        this.mainWindow = null;
+        this.gateway = null;
+        this.dbManager = null;
+        this.agentDaemon = null;
+        this.taskRepo = null;
+        this.workspaceRepo = null;
+        this.settings = DEFAULT_SETTINGS;
+        this.connectedChannels = 0;
+        this.activeTaskCount = 0;
+        this.quickInputWindow = null;
+        this.currentQuickTaskId = null;
+        this.quickTaskAccumulatedResponse = '';
+        this.currentStepInfo = '';
+        const userDataPath = electron_1.app.getPath('userData');
+        this.legacySettingsPath = path.join(userDataPath, LEGACY_SETTINGS_FILE);
+    }
+    /**
+     * Initialize the tray manager
+     */
+    async initialize(mainWindow, gateway, dbManager, agentDaemon, options = {}) {
+        this.mainWindow = mainWindow;
+        this.gateway = gateway;
+        this.dbManager = dbManager;
+        this.agentDaemon = agentDaemon || null;
+        // Initialize repositories
+        const db = dbManager.getDatabase();
+        this.taskRepo = new repositories_1.TaskRepository(db);
+        this.workspaceRepo = new repositories_1.WorkspaceRepository(db);
+        // Load settings
+        this.loadSettings();
+        // Apply options overrides
+        if (options.showDockIcon !== undefined) {
+            this.settings.showDockIcon = options.showDockIcon;
+        }
+        if (options.startMinimized !== undefined) {
+            this.settings.startMinimized = options.startMinimized;
+        }
+        if (options.closeToTray !== undefined) {
+            this.settings.closeToTray = options.closeToTray;
+        }
+        // Create tray if enabled
+        if (this.settings.enabled) {
+            this.createTray();
+        }
+        // Apply dock icon setting (macOS only)
+        this.applyDockIconSetting();
+        // Handle start minimized
+        if (this.settings.startMinimized && this.mainWindow) {
+            this.mainWindow.hide();
+        }
+        // Set up window close behavior
+        this.setupCloseToTray();
+        // Update status periodically
+        this.startStatusUpdates();
+        // Set up task event listening for quick input responses
+        this.setupTaskEventListener();
+        // Initialize quick input window
+        this.quickInputWindow = new QuickInputWindow_1.QuickInputWindow();
+        this.quickInputWindow.setOnSubmit((task, workspaceId) => {
+            this.handleQuickTaskSubmit(task, workspaceId);
+        });
+        this.quickInputWindow.setOnOpenMain(() => {
+            this.showMainWindow();
+            this.quickInputWindow?.hide();
+        });
+        // Register global shortcut for quick input (Cmd+Shift+Space)
+        this.registerGlobalShortcut();
+        console.log('[TrayManager] Initialized');
+    }
+    /**
+     * Set up listener for task events to stream to quick input
+     */
+    setupTaskEventListener() {
+        if (!this.agentDaemon)
+            return;
+        // Listen for assistant messages (the main text response)
+        this.agentDaemon.on('assistant_message', (event) => {
+            if (event.taskId !== this.currentQuickTaskId)
+                return;
+            const message = event.message || '';
+            if (message) {
+                // Append to accumulated response (assistant may send multiple messages)
+                if (this.quickTaskAccumulatedResponse) {
+                    this.quickTaskAccumulatedResponse += '\n\n' + message;
+                }
+                else {
+                    this.quickTaskAccumulatedResponse = message;
+                }
+                this.quickInputWindow?.updateResponse(this.formatResponseWithQuestion(this.quickTaskAccumulatedResponse), false);
+            }
+        });
+        // Listen for progress updates
+        this.agentDaemon.on('progress_update', (event) => {
+            if (event.taskId !== this.currentQuickTaskId)
+                return;
+            // Only show progress if we don't have response content yet
+            if (!this.quickTaskAccumulatedResponse && event.message) {
+                this.quickInputWindow?.updateResponse(`<p style="color: rgba(255,255,255,0.6);">${event.message}</p>`, false);
+            }
+        });
+        // Listen for task completion
+        this.agentDaemon.on('task_completed', (event) => {
+            if (event.taskId !== this.currentQuickTaskId)
+                return;
+            // Show the accumulated response as complete (without step prefix)
+            const finalContent = this.quickTaskAccumulatedResponse || event.result || event.message || 'Task completed successfully';
+            this.quickInputWindow?.updateResponse(this.formatResponseWithQuestion(finalContent), true);
+            this.currentQuickTaskId = null;
+            this.quickTaskAccumulatedResponse = '';
+            this.currentStepInfo = '';
+        });
+        // Listen for errors
+        this.agentDaemon.on('error', (event) => {
+            if (event.taskId !== this.currentQuickTaskId)
+                return;
+            const question = this.quickInputWindow?.getCurrentQuestion() || '';
+            const questionHtml = question ? `<div class="user-question"><strong>You:</strong> ${question.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')}</div>` : '';
+            this.quickInputWindow?.updateResponse(`${questionHtml}<div class="error-message">Error: ${event.message || 'An error occurred'}</div>`, true);
+            this.currentQuickTaskId = null;
+            this.quickTaskAccumulatedResponse = '';
+            this.currentStepInfo = '';
+        });
+        // Listen for step started (show what step is being executed)
+        this.agentDaemon.on('step_started', (event) => {
+            if (event.taskId !== this.currentQuickTaskId)
+                return;
+            // Show step info above the response
+            if (event.step?.description) {
+                const stepInfo = `**Step ${event.step.id}:** ${event.step.description}\n\n`;
+                // Prepend step info (it will be replaced by next step)
+                this.currentStepInfo = stepInfo;
+                this.quickInputWindow?.updateResponse(this.formatResponseWithQuestion(this.currentStepInfo + this.quickTaskAccumulatedResponse), false);
+            }
+        });
+        // Listen for plan created (show what the agent is going to do)
+        this.agentDaemon.on('plan_created', (event) => {
+            if (event.taskId !== this.currentQuickTaskId)
+                return;
+            if (event.plan?.steps && event.plan.steps.length > 0) {
+                const planSummary = event.plan.steps.map((s, i) => `${i + 1}. ${s.description}`).join('\n');
+                this.quickTaskAccumulatedResponse = `**Plan:**\n${planSummary}\n\n`;
+                this.quickInputWindow?.updateResponse(this.formatResponseWithQuestion(this.quickTaskAccumulatedResponse), false);
+            }
+        });
+    }
+    /**
+     * Format response text for HTML display
+     */
+    formatResponseForDisplay(text) {
+        // Basic markdown-like formatting
+        return text
+            // Escape HTML
+            .replace(/&/g, '&amp;')
+            .replace(/</g, '&lt;')
+            .replace(/>/g, '&gt;')
+            // Bold
+            .replace(/\*\*(.*?)\*\*/g, '<strong>$1</strong>')
+            // Code blocks
+            .replace(/```(\w*)\n?([\s\S]*?)```/g, '<pre><code>$2</code></pre>')
+            // Inline code
+            .replace(/`([^`]+)`/g, '<code>$1</code>')
+            // Line breaks
+            .replace(/\n/g, '<br>');
+    }
+    /**
+     * Format response with user's question prepended
+     */
+    formatResponseWithQuestion(text) {
+        const question = this.quickInputWindow?.getCurrentQuestion() || '';
+        const formattedResponse = this.formatResponseForDisplay(text);
+        if (question) {
+            const escapedQuestion = question
+                .replace(/&/g, '&amp;')
+                .replace(/</g, '&lt;')
+                .replace(/>/g, '&gt;');
+            return `<div class="user-question"><strong>You:</strong> ${escapedQuestion}</div>${formattedResponse}`;
+        }
+        return formattedResponse;
+    }
+    /**
+     * Get or create the temp workspace
+     */
+    async getOrCreateTempWorkspace() {
+        if (!this.dbManager)
+            throw new Error('Database not available');
+        const db = this.dbManager.getDatabase();
+        // Check if temp workspace exists
+        const existing = this.workspaceRepo?.findById(types_1.TEMP_WORKSPACE_ID);
+        if (existing) {
+            const updatedPermissions = {
+                ...existing.permissions,
+                read: true,
+                write: true,
+                delete: true,
+                network: true,
+                shell: existing.permissions.shell ?? false,
+                unrestrictedFileAccess: true,
+            };
+            if (!existing.permissions.unrestrictedFileAccess) {
+                this.workspaceRepo?.updatePermissions(existing.id, updatedPermissions);
+            }
+            // Verify directory exists
+            if (fs.existsSync(existing.path)) {
+                return { ...existing, permissions: updatedPermissions, isTemp: true };
+            }
+            // Directory deleted, remove and recreate
+            this.workspaceRepo?.delete(types_1.TEMP_WORKSPACE_ID);
+        }
+        // Create temp directory
+        const tempDir = path.join(os.tmpdir(), 'cowork-os-temp');
+        if (!fs.existsSync(tempDir)) {
+            fs.mkdirSync(tempDir, { recursive: true });
+        }
+        // Create workspace record
+        const tempWorkspace = {
+            id: types_1.TEMP_WORKSPACE_ID,
+            name: types_1.TEMP_WORKSPACE_NAME,
+            path: tempDir,
+            createdAt: Date.now(),
+            permissions: {
+                read: true,
+                write: true,
+                delete: true,
+                network: true,
+                shell: false,
+                unrestrictedFileAccess: true,
+            },
+            isTemp: true,
+        };
+        const stmt = db.prepare(`
+      INSERT OR REPLACE INTO workspaces (id, name, path, created_at, permissions)
+      VALUES (?, ?, ?, ?, ?)
+    `);
+        stmt.run(tempWorkspace.id, tempWorkspace.name, tempWorkspace.path, tempWorkspace.createdAt, JSON.stringify(tempWorkspace.permissions));
+        return tempWorkspace;
+    }
+    /**
+     * Handle quick task submission - create and run task
+     */
+    async handleQuickTaskSubmit(prompt, workspaceId) {
+        if (!this.taskRepo || !this.workspaceRepo || !this.agentDaemon) {
+            // Fall back to sending to main window
+            console.log('[TrayManager] Agent daemon not available, falling back to main window');
+            this.showMainWindow();
+            this.mainWindow?.webContents.send('tray:quick-task', { task: prompt, workspaceId });
+            return;
+        }
+        // Show loading state and reset accumulated response
+        this.quickInputWindow?.showLoading();
+        this.quickTaskAccumulatedResponse = '';
+        this.currentStepInfo = '';
+        try {
+            // Get or select workspace
+            let wsId = workspaceId;
+            if (!wsId) {
+                // Get the first non-temp workspace, or use temp workspace as fallback
+                const workspaces = this.workspaceRepo.findAll().filter(w => w.id !== types_1.TEMP_WORKSPACE_ID);
+                if (workspaces.length > 0) {
+                    wsId = workspaces[0].id;
+                }
+                else {
+                    // No user workspaces, use temp workspace
+                    const tempWorkspace = await this.getOrCreateTempWorkspace();
+                    wsId = tempWorkspace.id;
+                }
+            }
+            // Create task
+            const task = this.taskRepo.create({
+                title: prompt.slice(0, 50) + (prompt.length > 50 ? '...' : ''),
+                prompt,
+                workspaceId: wsId,
+                status: 'queued',
+            });
+            this.currentQuickTaskId = task.id;
+            // Start task execution
+            await this.agentDaemon.startTask(task);
+            // Also notify main window so it updates the task list
+            this.mainWindow?.webContents.send('tray:task-created', { taskId: task.id });
+        }
+        catch (error) {
+            console.error('[TrayManager] Failed to create quick task:', error);
+            const question = this.quickInputWindow?.getCurrentQuestion() || '';
+            const questionHtml = question ? `<div class="user-question"><strong>You:</strong> ${question.replace(/&/g, '&amp;').replace(/</g, '&lt;').replace(/>/g, '&gt;')}</div>` : '';
+            this.quickInputWindow?.updateResponse(`${questionHtml}<div class="error-message">Failed to create task: ${error instanceof Error ? error.message : 'Unknown error'}</div>`, true);
+            this.currentQuickTaskId = null;
+        }
+    }
+    /**
+     * Show the quick input window
+     */
+    showQuickInput() {
+        this.quickInputWindow?.show();
+    }
+    /**
+     * Toggle the quick input window
+     */
+    toggleQuickInput() {
+        this.quickInputWindow?.toggle();
+    }
+    /**
+     * Register global keyboard shortcut for quick input
+     */
+    registerGlobalShortcut() {
+        try {
+            // Unregister first in case it's already registered
+            electron_1.globalShortcut.unregister('CommandOrControl+Shift+Space');
+            const registered = electron_1.globalShortcut.register('CommandOrControl+Shift+Space', () => {
+                this.showQuickInput();
+            });
+            if (registered) {
+                console.log('[TrayManager] Global shortcut registered: Cmd+Shift+Space');
+            }
+            else {
+                console.warn('[TrayManager] Failed to register global shortcut - may be in use by another app');
+            }
+        }
+        catch (error) {
+            console.error('[TrayManager] Error registering global shortcut:', error);
+        }
+    }
+    /**
+     * Unregister global keyboard shortcut
+     */
+    unregisterGlobalShortcut() {
+        try {
+            electron_1.globalShortcut.unregister('CommandOrControl+Shift+Space');
+            console.log('[TrayManager] Global shortcut unregistered');
+        }
+        catch (error) {
+            console.error('[TrayManager] Error unregistering global shortcut:', error);
+        }
+    }
+    /**
+     * Create the system tray icon
+     */
+    createTray() {
+        if (this.tray) {
+            return;
+        }
+        try {
+            // Create tray icon (use template image for macOS)
+            const icon = this.getTrayIcon('idle');
+            this.tray = new electron_1.Tray(icon);
+            this.tray.setToolTip('CoWork OS');
+            // Build and set context menu
+            this.updateContextMenu();
+            // Handle click events - always show context menu on click
+            this.tray.on('click', () => {
+                this.tray?.popUpContextMenu();
+            });
+        }
+        catch (error) {
+            console.error('[TrayManager] Failed to create tray:', error);
+        }
+    }
+    /**
+     * Get or create tray icon
+     */
+    getTrayIcon(state) {
+        // Try to load from file first
+        const iconPath = this.getIconPath(state === 'active' ? 'trayActiveTemplate' : 'trayTemplate');
+        const fs = require('fs');
+        if (fs.existsSync(iconPath)) {
+            const icon = electron_1.nativeImage.createFromPath(iconPath);
+            if (process.platform === 'darwin') {
+                icon.setTemplateImage(true);
+            }
+            return icon;
+        }
+        // Create programmatic icon if file doesn't exist
+        return this.createProgrammaticIcon(state);
+    }
+    /**
+     * Create a programmatic tray icon using raw RGBA bitmap
+     * More reliable than SVG data URLs for Electron tray icons
+     */
+    createProgrammaticIcon(state) {
+        // Standard macOS menu bar icon size (16x16 for 1x, 32x32 for 2x retina)
+        const size = 16;
+        const scale = 2; // Create at 2x for retina
+        const actualSize = size * scale;
+        // Create RGBA buffer (4 bytes per pixel)
+        const buffer = Buffer.alloc(actualSize * actualSize * 4);
+        // Get color based on state
+        const [r, g, b] = state === 'error' ? [255, 59, 48] : // Red
+            state === 'active' ? [0, 122, 255] : // Blue
+                [255, 255, 255]; // White
+        // Draw a simple filled circle
+        const centerX = actualSize / 2;
+        const centerY = actualSize / 2;
+        const outerRadius = actualSize / 2 - 2;
+        const innerRadius = outerRadius - 4;
+        for (let y = 0; y < actualSize; y++) {
+            for (let x = 0; x < actualSize; x++) {
+                const dx = x - centerX;
+                const dy = y - centerY;
+                const distance = Math.sqrt(dx * dx + dy * dy);
+                const idx = (y * actualSize + x) * 4;
+                // Draw ring (between inner and outer radius)
+                if (distance <= outerRadius && distance >= innerRadius) {
+                    // Anti-aliasing at edges
+                    let alpha = 255;
+                    if (distance > outerRadius - 1) {
+                        alpha = Math.round(255 * (outerRadius - distance));
+                    }
+                    else if (distance < innerRadius + 1) {
+                        alpha = Math.round(255 * (distance - innerRadius));
+                    }
+                    alpha = Math.max(0, Math.min(255, alpha));
+                    buffer[idx] = r;
+                    buffer[idx + 1] = g;
+                    buffer[idx + 2] = b;
+                    buffer[idx + 3] = alpha;
+                }
+                else {
+                    // Transparent
+                    buffer[idx] = 0;
+                    buffer[idx + 1] = 0;
+                    buffer[idx + 2] = 0;
+                    buffer[idx + 3] = 0;
+                }
+            }
+        }
+        return electron_1.nativeImage.createFromBuffer(buffer, {
+            width: actualSize,
+            height: actualSize,
+            scaleFactor: scale,
+        });
+    }
+    /**
+     * Get the path to a tray icon
+     */
+    getIconPath(name) {
+        const isDev = process.env.NODE_ENV === 'development';
+        const basePath = isDev
+            ? path.join(__dirname, '../../../assets/tray')
+            : path.join(process.resourcesPath, 'assets/tray');
+        // Use PNG for cross-platform compatibility
+        const extension = process.platform === 'darwin' ? 'png' : 'png';
+        return path.join(basePath, `${name}.${extension}`);
+    }
+    /**
+     * Update the tray context menu
+     */
+    updateContextMenu() {
+        if (!this.tray)
+            return;
+        const statusText = this.getStatusText();
+        const workspaces = this.getWorkspaces();
+        const menuTemplate = [
+            // Status section
+            {
+                label: statusText,
+                enabled: false,
+                icon: this.getStatusIcon(),
+            },
+            { type: 'separator' },
+            // Quick actions
+            {
+                label: 'Quick Task...',
+                accelerator: 'CmdOrCtrl+Shift+Space',
+                click: () => {
+                    this.showQuickInput();
+                },
+            },
+            {
+                label: 'New Task...',
+                accelerator: 'CmdOrCtrl+N',
+                click: () => {
+                    this.showMainWindow();
+                    this.mainWindow?.webContents.send('tray:new-task');
+                },
+            },
+            { type: 'separator' },
+            // Workspaces submenu
+            {
+                label: 'Workspaces',
+                submenu: workspaces.length > 0
+                    ? workspaces.map((ws) => ({
+                        label: ws.name,
+                        click: () => {
+                            this.showMainWindow();
+                            this.mainWindow?.webContents.send('tray:select-workspace', ws.id);
+                        },
+                    }))
+                    : [{ label: 'No workspaces', enabled: false }],
+            },
+            // Channels submenu
+            {
+                label: 'Channels',
+                submenu: this.buildChannelsSubmenu(),
+            },
+            { type: 'separator' },
+            // Window controls
+            {
+                label: this.mainWindow?.isVisible() ? 'Hide Window' : 'Show Window',
+                accelerator: 'CmdOrCtrl+H',
+                click: () => this.toggleMainWindow(),
+            },
+            {
+                label: 'Settings...',
+                accelerator: 'CmdOrCtrl+,',
+                click: () => {
+                    this.showMainWindow();
+                    this.mainWindow?.webContents.send('tray:open-settings');
+                },
+            },
+            { type: 'separator' },
+            // App controls
+            {
+                label: 'About CoWork OS',
+                click: () => {
+                    this.showMainWindow();
+                    this.mainWindow?.webContents.send('tray:open-about');
+                },
+            },
+            {
+                label: 'Check for Updates...',
+                click: () => {
+                    this.showMainWindow();
+                    this.mainWindow?.webContents.send('tray:check-updates');
+                },
+            },
+            { type: 'separator' },
+            {
+                label: 'Quit CoWork OS',
+                accelerator: 'CmdOrCtrl+Q',
+                click: () => {
+                    // Force quit (bypass close-to-tray)
+                    this.settings.closeToTray = false;
+                    electron_1.app.quit();
+                },
+            },
+        ];
+        const contextMenu = electron_1.Menu.buildFromTemplate(menuTemplate);
+        this.tray.setContextMenu(contextMenu);
+    }
+    /**
+     * Build the channels submenu
+     */
+    buildChannelsSubmenu() {
+        const channels = this.gateway?.getChannels() || [];
+        if (channels.length === 0) {
+            return [{ label: 'No channels configured', enabled: false }];
+        }
+        return channels.map((channel) => {
+            const statusIcon = channel.status === 'connected' ? '🟢' :
+                channel.status === 'connecting' ? '🟡' :
+                    channel.status === 'error' ? '🔴' : '⚪';
+            return {
+                label: `${statusIcon} ${channel.name} (${channel.type})`,
+                enabled: false,
+            };
+        });
+    }
+    /**
+     * Get status text for the menu
+     */
+    getStatusText() {
+        const channels = this.gateway?.getChannels() || [];
+        this.connectedChannels = channels.filter((c) => c.status === 'connected').length;
+        if (this.activeTaskCount > 0) {
+            return `Working on ${this.activeTaskCount} task${this.activeTaskCount > 1 ? 's' : ''}`;
+        }
+        if (this.connectedChannels > 0) {
+            return `${this.connectedChannels} channel${this.connectedChannels > 1 ? 's' : ''} connected`;
+        }
+        return 'Ready';
+    }
+    /**
+     * Get status icon for the menu
+     */
+    getStatusIcon() {
+        // Return undefined for now - icons in menu items can be complex
+        return undefined;
+    }
+    /**
+     * Get workspaces from database (excluding temp workspace)
+     */
+    getWorkspaces() {
+        if (!this.dbManager)
+            return [];
+        try {
+            const db = this.dbManager.getDatabase();
+            const stmt = db.prepare('SELECT id, name, path FROM workspaces WHERE id != ? ORDER BY name');
+            return stmt.all(types_1.TEMP_WORKSPACE_ID);
+        }
+        catch (error) {
+            console.error('[TrayManager] Failed to get workspaces:', error);
+            return [];
+        }
+    }
+    /**
+     * Toggle main window visibility
+     */
+    toggleMainWindow() {
+        if (!this.mainWindow)
+            return;
+        if (this.mainWindow.isVisible()) {
+            this.mainWindow.hide();
+        }
+        else {
+            this.showMainWindow();
+        }
+        // Update menu to reflect new state
+        this.updateContextMenu();
+    }
+    /**
+     * Show and focus the main window
+     */
+    showMainWindow() {
+        if (!this.mainWindow)
+            return;
+        this.mainWindow.show();
+        this.mainWindow.focus();
+        // On macOS, also bring app to foreground
+        if (process.platform === 'darwin') {
+            electron_1.app.dock?.show();
+        }
+    }
+    /**
+     * Set up close-to-tray behavior
+     */
+    setupCloseToTray() {
+        if (!this.mainWindow)
+            return;
+        this.mainWindow.on('close', (event) => {
+            if (this.settings.closeToTray && this.tray) {
+                event.preventDefault();
+                this.mainWindow?.hide();
+                // On macOS, hide from dock when minimized to tray
+                if (process.platform === 'darwin' && !this.settings.showDockIcon) {
+                    electron_1.app.dock?.hide();
+                }
+            }
+        });
+    }
+    /**
+     * Apply dock icon visibility setting (macOS only)
+     */
+    applyDockIconSetting() {
+        if (process.platform !== 'darwin')
+            return;
+        if (this.settings.showDockIcon) {
+            electron_1.app.dock?.show();
+        }
+        else {
+            electron_1.app.dock?.hide();
+        }
+    }
+    /**
+     * Start periodic status updates
+     */
+    startStatusUpdates() {
+        // Update every 5 seconds
+        setInterval(() => {
+            this.updateContextMenu();
+            this.updateTrayIcon();
+        }, 5000);
+    }
+    /**
+     * Update tray icon based on status
+     */
+    updateTrayIcon() {
+        if (!this.tray)
+            return;
+        // Determine icon state based on app status
+        const state = this.activeTaskCount > 0 ? 'active' : 'idle';
+        const icon = this.getTrayIcon(state);
+        this.tray.setImage(icon);
+    }
+    /**
+     * Update active task count
+     */
+    setActiveTaskCount(count) {
+        this.activeTaskCount = count;
+        this.updateContextMenu();
+        this.updateTrayIcon();
+    }
+    /**
+     * Migrate settings from legacy JSON file to encrypted database
+     */
+    migrateFromLegacyFile() {
+        if (TrayManager.migrationCompleted)
+            return;
+        try {
+            if (!SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                return;
+            }
+            const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+            // Check if already migrated
+            if (repository.exists('tray')) {
+                TrayManager.migrationCompleted = true;
+                return;
+            }
+            // Check if legacy file exists
+            if (!fs.existsSync(this.legacySettingsPath)) {
+                TrayManager.migrationCompleted = true;
+                return;
+            }
+            console.log('[TrayManager] 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 {
+                const data = fs.readFileSync(this.legacySettingsPath, 'utf-8');
+                const parsed = JSON.parse(data);
+                const merged = { ...DEFAULT_SETTINGS, ...parsed };
+                repository.save('tray', merged);
+                console.log('[TrayManager] Settings migrated to encrypted database');
+                // Migration successful - delete backup and original
+                fs.unlinkSync(backupPath);
+                fs.unlinkSync(this.legacySettingsPath);
+                console.log('[TrayManager] Migration complete, cleaned up legacy files');
+                TrayManager.migrationCompleted = true;
+            }
+            catch (migrationError) {
+                console.error('[TrayManager] Migration failed, backup preserved at:', backupPath);
+                throw migrationError;
+            }
+        }
+        catch (error) {
+            console.error('[TrayManager] Migration failed:', error);
+        }
+    }
+    /**
+     * Load settings from encrypted database
+     */
+    loadSettings() {
+        // Migrate from legacy file if needed
+        this.migrateFromLegacyFile();
+        try {
+            if (SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+                const stored = repository.load('tray');
+                if (stored) {
+                    this.settings = { ...DEFAULT_SETTINGS, ...stored };
+                    console.log('[TrayManager] Loaded settings from encrypted database');
+                    return;
+                }
+            }
+        }
+        catch (error) {
+            console.error('[TrayManager] Failed to load settings:', error);
+        }
+        // Fall back to defaults
+        this.settings = { ...DEFAULT_SETTINGS };
+    }
+    /**
+     * Save settings to encrypted database
+     */
+    saveSettings(settings) {
+        this.settings = { ...this.settings, ...settings };
+        try {
+            if (SecureSettingsRepository_1.SecureSettingsRepository.isInitialized()) {
+                const repository = SecureSettingsRepository_1.SecureSettingsRepository.getInstance();
+                repository.save('tray', this.settings);
+                console.log('[TrayManager] Settings saved to encrypted database');
+            }
+            else {
+                console.warn('[TrayManager] SecureSettingsRepository not initialized, settings not persisted');
+            }
+            // Apply settings immediately
+            this.applyDockIconSetting();
+            // Recreate tray if enabled status changed
+            if (settings.enabled !== undefined) {
+                if (settings.enabled && !this.tray) {
+                    this.createTray();
+                }
+                else if (!settings.enabled && this.tray) {
+                    this.destroy();
+                }
+            }
+        }
+        catch (error) {
+            console.error('[TrayManager] Failed to save settings:', error);
+        }
+    }
+    /**
+     * Get current settings
+     */
+    getSettings() {
+        return { ...this.settings };
+    }
+    /**
+     * Show a notification from the tray
+     */
+    showNotification(title, body) {
+        if (!this.settings.showNotifications)
+            return;
+        const { Notification } = require('electron');
+        if (Notification.isSupported()) {
+            const notification = new Notification({
+                title,
+                body,
+                silent: false,
+            });
+            notification.on('click', () => {
+                this.showMainWindow();
+            });
+            notification.show();
+        }
+    }
+    /**
+     * Destroy the tray
+     */
+    destroy() {
+        // Unregister global shortcut
+        this.unregisterGlobalShortcut();
+        if (this.quickInputWindow) {
+            this.quickInputWindow.destroy();
+            this.quickInputWindow = null;
+        }
+        if (this.tray) {
+            this.tray.destroy();
+            this.tray = null;
+        }
+    }
+}
+exports.TrayManager = TrayManager;
+TrayManager.instance = null;
+TrayManager.migrationCompleted = false;
+exports.trayManager = TrayManager.getInstance();