cowork-os 0.3.21

package/dist/electron/electron/ipc/mission-control-handlers.js

@@ -0,0 +1,141 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.setupMissionControlHandlers = setupMissionControlHandlers;
+const electron_1 = require("electron");
+const types_1 = require("../../shared/types");
+const rate_limiter_1 = require("../utils/rate-limiter");
+const validation_1 = require("../utils/validation");
+// Get main window for event broadcasting
+let mainWindowGetter = null;
+function getMainWindow() {
+    return mainWindowGetter?.() ?? null;
+}
+/**
+ * Rate limit check helper
+ */
+function checkRateLimit(channel) {
+    if (!rate_limiter_1.rateLimiter.check(channel)) {
+        throw new Error(`Rate limit exceeded for ${channel}`);
+    }
+}
+/**
+ * Set up Mission Control IPC handlers
+ */
+function setupMissionControlHandlers(deps) {
+    mainWindowGetter = deps.getMainWindow;
+    const { agentRoleRepo, taskSubscriptionRepo, standupService, heartbeatService, } = deps;
+    // ============ Heartbeat Handlers ============
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HEARTBEAT_GET_CONFIG, async (_, agentRoleId) => {
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, agentRoleId, 'agent role ID');
+        const role = agentRoleRepo.findById(validated);
+        if (!role) {
+            throw new Error('Agent role not found');
+        }
+        return {
+            heartbeatEnabled: role.heartbeatEnabled,
+            heartbeatIntervalMinutes: role.heartbeatIntervalMinutes,
+            heartbeatStaggerOffset: role.heartbeatStaggerOffset,
+            lastHeartbeatAt: role.lastHeartbeatAt,
+            heartbeatStatus: role.heartbeatStatus,
+        };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HEARTBEAT_UPDATE_CONFIG, async (_, agentRoleId, config) => {
+        checkRateLimit(types_1.IPC_CHANNELS.HEARTBEAT_UPDATE_CONFIG);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, agentRoleId, 'agent role ID');
+        const result = agentRoleRepo.updateHeartbeatConfig(validated, config);
+        if (result) {
+            heartbeatService.updateAgentConfig(validated, config);
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.HEARTBEAT_EVENT, {
+                type: 'config_updated',
+                agentRoleId: validated,
+                config,
+            });
+        }
+        return result;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HEARTBEAT_TRIGGER, async (_, agentRoleId) => {
+        checkRateLimit(types_1.IPC_CHANNELS.HEARTBEAT_TRIGGER);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, agentRoleId, 'agent role ID');
+        const result = await heartbeatService.triggerHeartbeat(validated);
+        getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.HEARTBEAT_EVENT, {
+            type: 'triggered',
+            agentRoleId: validated,
+            result,
+        });
+        return result;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HEARTBEAT_GET_STATUS, async (_, agentRoleId) => {
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, agentRoleId, 'agent role ID');
+        return heartbeatService.getStatus(validated);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.HEARTBEAT_GET_ALL_STATUS, async () => {
+        return heartbeatService.getAllStatus();
+    });
+    // Forward heartbeat events to renderer
+    heartbeatService.on('heartbeat', (event) => {
+        getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.HEARTBEAT_EVENT, event);
+    });
+    // ============ Task Subscription Handlers ============
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SUBSCRIPTION_LIST, async (_, taskId) => {
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, taskId, 'task ID');
+        return taskSubscriptionRepo.getSubscribers(validated);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SUBSCRIPTION_ADD, async (_, taskId, agentRoleId, reason) => {
+        checkRateLimit(types_1.IPC_CHANNELS.SUBSCRIPTION_ADD);
+        const validatedTaskId = (0, validation_1.validateInput)(validation_1.UUIDSchema, taskId, 'task ID');
+        const validatedAgentRoleId = (0, validation_1.validateInput)(validation_1.UUIDSchema, agentRoleId, 'agent role ID');
+        const subscription = taskSubscriptionRepo.subscribe(validatedTaskId, validatedAgentRoleId, reason);
+        getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.SUBSCRIPTION_EVENT, {
+            type: 'added',
+            subscription,
+        });
+        return subscription;
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SUBSCRIPTION_REMOVE, async (_, taskId, agentRoleId) => {
+        checkRateLimit(types_1.IPC_CHANNELS.SUBSCRIPTION_REMOVE);
+        const validatedTaskId = (0, validation_1.validateInput)(validation_1.UUIDSchema, taskId, 'task ID');
+        const validatedAgentRoleId = (0, validation_1.validateInput)(validation_1.UUIDSchema, agentRoleId, 'agent role ID');
+        const success = taskSubscriptionRepo.unsubscribe(validatedTaskId, validatedAgentRoleId);
+        if (success) {
+            getMainWindow()?.webContents.send(types_1.IPC_CHANNELS.SUBSCRIPTION_EVENT, {
+                type: 'removed',
+                taskId: validatedTaskId,
+                agentRoleId: validatedAgentRoleId,
+            });
+        }
+        return { success };
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SUBSCRIPTION_GET_SUBSCRIBERS, async (_, taskId) => {
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, taskId, 'task ID');
+        return taskSubscriptionRepo.getSubscribers(validated);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.SUBSCRIPTION_GET_FOR_AGENT, async (_, agentRoleId) => {
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, agentRoleId, 'agent role ID');
+        return taskSubscriptionRepo.getSubscriptionsForAgent(validated);
+    });
+    // ============ Standup Report Handlers ============
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.STANDUP_GENERATE, async (_, workspaceId) => {
+        checkRateLimit(types_1.IPC_CHANNELS.STANDUP_GENERATE);
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, workspaceId, 'workspace ID');
+        return standupService.generateReport(validated);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.STANDUP_GET_LATEST, async (_, workspaceId) => {
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, workspaceId, 'workspace ID');
+        return standupService.getLatest(validated);
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.STANDUP_LIST, async (_, workspaceId, limit) => {
+        const validated = (0, validation_1.validateInput)(validation_1.UUIDSchema, workspaceId, 'workspace ID');
+        return standupService.list({ workspaceId: validated, limit });
+    });
+    electron_1.ipcMain.handle(types_1.IPC_CHANNELS.STANDUP_DELIVER, async (_, reportId, channelType, channelId) => {
+        checkRateLimit(types_1.IPC_CHANNELS.STANDUP_DELIVER);
+        const validatedReportId = (0, validation_1.validateInput)(validation_1.UUIDSchema, reportId, 'report ID');
+        const report = standupService.findById(validatedReportId);
+        if (!report) {
+            throw new Error('Standup report not found');
+        }
+        await standupService.deliverReport(report, { channelType, channelId });
+        return { success: true };
+    });
+    console.log('[MissionControl] Handlers initialized');
+}

package/dist/electron/electron/main.js

@@ -0,0 +1,448 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const path_1 = __importDefault(require("path"));
+const url_1 = require("url");
+const electron_1 = require("electron");
+const schema_1 = require("./database/schema");
+const SecureSettingsRepository_1 = require("./database/SecureSettingsRepository");
+const handlers_1 = require("./ipc/handlers");
+const mission_control_handlers_1 = require("./ipc/mission-control-handlers");
+const TaskSubscriptionRepository_1 = require("./agents/TaskSubscriptionRepository");
+const StandupReportService_1 = require("./reports/StandupReportService");
+const HeartbeatService_1 = require("./agents/HeartbeatService");
+const AgentRoleRepository_1 = require("./agents/AgentRoleRepository");
+const MentionRepository_1 = require("./agents/MentionRepository");
+const ActivityRepository_1 = require("./activity/ActivityRepository");
+const WorkingStateRepository_1 = require("./agents/WorkingStateRepository");
+const daemon_1 = require("./agent/daemon");
+const repositories_1 = require("./database/repositories");
+const llm_1 = require("./agent/llm");
+const search_1 = require("./agent/search");
+const gateway_1 = require("./gateway");
+const updater_1 = require("./updater");
+const env_migration_1 = require("./utils/env-migration");
+const guardrail_manager_1 = require("./guardrails/guardrail-manager");
+const appearance_manager_1 = require("./settings/appearance-manager");
+const personality_manager_1 = require("./settings/personality-manager");
+const MCPClientManager_1 = require("./mcp/client/MCPClientManager");
+const tray_1 = require("./tray");
+const cron_1 = require("./cron");
+const MemoryService_1 = require("./memory/MemoryService");
+const control_plane_1 = require("./control-plane");
+// Live Canvas feature
+const canvas_1 = require("./canvas");
+const canvas_handlers_1 = require("./ipc/canvas-handlers");
+let mainWindow = null;
+let dbManager;
+let agentDaemon;
+let channelGateway;
+let cronService = null;
+// Suppress GPU-related Chromium errors that occur with transparent windows and vibrancy
+// These are cosmetic errors that don't affect functionality
+electron_1.app.commandLine.appendSwitch('disable-gpu-driver-bug-workarounds');
+electron_1.app.commandLine.appendSwitch('enable-gpu-rasterization');
+electron_1.app.commandLine.appendSwitch('ignore-gpu-blocklist');
+// Register canvas:// protocol scheme (must be called before app.ready)
+(0, canvas_1.registerCanvasScheme)();
+function createWindow() {
+    mainWindow = new electron_1.BrowserWindow({
+        width: 1600,
+        height: 1000,
+        minWidth: 1200,
+        minHeight: 800,
+        center: true,
+        titleBarStyle: 'hiddenInset',
+        vibrancy: 'under-window',
+        visualEffectState: 'active',
+        transparent: true,
+        backgroundColor: '#00000000',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            webviewTag: true, // Enable webview for canvas interactive mode
+            preload: path_1.default.join(__dirname, 'preload.js'),
+        },
+    });
+    // Load the app
+    if (process.env.NODE_ENV === 'development') {
+        mainWindow.loadURL('http://localhost:5173');
+        mainWindow.webContents.openDevTools();
+    }
+    else {
+        mainWindow.loadFile(path_1.default.join(__dirname, '../../renderer/index.html'));
+    }
+    mainWindow.on('closed', () => {
+        mainWindow = null;
+    });
+    // Open external links in the system browser instead of inside the app
+    mainWindow.webContents.setWindowOpenHandler(({ url }) => {
+        // Open all new window requests in external browser
+        electron_1.shell.openExternal(url);
+        return { action: 'deny' };
+    });
+    mainWindow.webContents.on('will-navigate', (event, url) => {
+        // Allow navigation to the app itself (dev server or file://), block external URLs
+        const appUrl = process.env.NODE_ENV === 'development'
+            ? 'http://localhost:5173'
+            : `file://${path_1.default.join(__dirname, '../../renderer')}`;
+        if (!url.startsWith(appUrl)) {
+            event.preventDefault();
+            electron_1.shell.openExternal(url);
+        }
+    });
+}
+electron_1.app.whenReady().then(async () => {
+    // Set up Content Security Policy for production builds
+    if (process.env.NODE_ENV !== 'development') {
+        const appRoot = (0, url_1.pathToFileURL)(path_1.default.join(__dirname, '../../renderer')).toString();
+        electron_1.session.defaultSession.webRequest.onHeadersReceived((details, callback) => {
+            if (!details.url.startsWith(appRoot)) {
+                callback({ responseHeaders: details.responseHeaders });
+                return;
+            }
+            callback({
+                responseHeaders: {
+                    ...details.responseHeaders,
+                    'Content-Security-Policy': [
+                        "default-src 'self'; " +
+                            "script-src 'self'; " +
+                            "style-src 'self' 'unsafe-inline'; " + // Allow inline styles for React
+                            "img-src 'self' data: https:; " + // Allow images from self, data URIs, and HTTPS
+                            "font-src 'self' data:; " + // Allow fonts from self and data URIs
+                            "connect-src 'self' https:; " + // Allow API calls to HTTPS endpoints
+                            "frame-ancestors 'none'; " + // Prevent embedding in iframes
+                            "form-action 'self';" // Restrict form submissions
+                    ],
+                },
+            });
+        });
+    }
+    // Initialize database first - required for SecureSettingsRepository
+    dbManager = new schema_1.DatabaseManager();
+    // Initialize secure settings repository for encrypted settings storage
+    // This MUST be done before provider factories so they can migrate legacy settings
+    new SecureSettingsRepository_1.SecureSettingsRepository(dbManager.getDatabase());
+    console.log('[Main] SecureSettingsRepository initialized');
+    // Initialize provider factories (loads settings from disk, migrates legacy files)
+    llm_1.LLMProviderFactory.initialize();
+    search_1.SearchProviderFactory.initialize();
+    guardrail_manager_1.GuardrailManager.initialize();
+    appearance_manager_1.AppearanceManager.initialize();
+    personality_manager_1.PersonalityManager.initialize();
+    // Migrate .env configuration to Settings (one-time upgrade path)
+    const migrationResult = await (0, env_migration_1.migrateEnvToSettings)();
+    // Initialize agent daemon
+    agentDaemon = new daemon_1.AgentDaemon(dbManager);
+    await agentDaemon.initialize();
+    // Initialize Memory Service for cross-session context
+    try {
+        MemoryService_1.MemoryService.initialize(dbManager);
+        console.log('[Main] Memory Service initialized');
+    }
+    catch (error) {
+        console.error('[Main] Failed to initialize Memory Service:', error);
+        // Don't fail app startup if memory init fails
+    }
+    // Initialize MCP Client Manager - auto-connects enabled servers on startup
+    try {
+        const mcpClientManager = MCPClientManager_1.MCPClientManager.getInstance();
+        await mcpClientManager.initialize();
+        console.log('[Main] MCP Client Manager initialized');
+    }
+    catch (error) {
+        console.error('[Main] Failed to initialize MCP Client Manager:', error);
+        // Don't fail app startup if MCP init fails
+    }
+    // Initialize Cron Service for scheduled task execution
+    try {
+        cronService = new cron_1.CronService({
+            cronEnabled: true,
+            storePath: (0, cron_1.getCronStorePath)(),
+            maxConcurrentRuns: 3, // Allow up to 3 concurrent jobs
+            // Webhook configuration (disabled by default, can be enabled in settings)
+            webhook: {
+                enabled: false, // Set to true to enable webhook triggers
+                port: 9876,
+                host: '127.0.0.1',
+                // secret: 'your-secret-here', // Uncomment and set for secure webhooks
+            },
+            createTask: async (params) => {
+                const task = await agentDaemon.createTask({
+                    title: params.title,
+                    prompt: params.prompt,
+                    workspaceId: params.workspaceId,
+                });
+                return { id: task.id };
+            },
+            // Channel delivery handler - sends job results to messaging platforms
+            deliverToChannel: async (params) => {
+                if (!channelGateway) {
+                    console.warn('[Cron] Cannot deliver to channel - gateway not initialized');
+                    return;
+                }
+                // Build the message
+                const statusEmoji = params.status === 'ok' ? '✅' : params.status === 'error' ? '❌' : '⏱️';
+                let message = `${statusEmoji} **Scheduled Task: ${params.jobName}**\n\n`;
+                if (params.status === 'ok') {
+                    message += `Task completed successfully.\n`;
+                }
+                else if (params.status === 'error') {
+                    message += `Task failed.\n`;
+                }
+                else {
+                    message += `Task timed out.\n`;
+                }
+                if (params.error) {
+                    message += `\n**Error:** ${params.error}\n`;
+                }
+                if (params.taskId && !params.summaryOnly) {
+                    message += `\n_Task ID: ${params.taskId}_`;
+                }
+                // Find the channel to verify it exists
+                const channels = channelGateway.getChannels();
+                const channel = channels.find((ch) => ch.type === params.channelType && ch.id === params.channelId);
+                if (!channel) {
+                    console.warn(`[Cron] Channel not found: ${params.channelType}:${params.channelId}`);
+                    return;
+                }
+                try {
+                    // Send the message via the gateway
+                    await channelGateway.sendMessage(params.channelType, params.channelId, message, { parseMode: 'markdown' });
+                    console.log(`[Cron] Delivered to ${params.channelType}:${params.channelId}`);
+                }
+                catch (err) {
+                    console.error(`[Cron] Failed to deliver to ${params.channelType}:${params.channelId}:`, err);
+                }
+            },
+            onEvent: async (evt) => {
+                // Forward cron events to renderer
+                if (mainWindow?.webContents) {
+                    mainWindow.webContents.send('cron:event', evt);
+                }
+                console.log('[Cron] Event:', evt.action, evt.jobId);
+                // Show desktop notification when scheduled task finishes
+                if (evt.action === 'finished') {
+                    const statusEmoji = evt.status === 'ok' ? '✅' : evt.status === 'error' ? '❌' : '⏱️';
+                    const statusText = evt.status === 'ok' ? 'completed' : evt.status === 'error' ? 'failed' : 'timed out';
+                    // Add in-app notification
+                    const notificationService = (0, handlers_1.getNotificationService)();
+                    if (notificationService) {
+                        try {
+                            // Get job name for the notification
+                            const job = cronService ? await cronService.get(evt.jobId) : null;
+                            const jobName = job?.name || 'Scheduled Task';
+                            await notificationService.add({
+                                type: evt.status === 'ok' ? 'task_completed' : 'task_failed',
+                                title: `${statusEmoji} ${jobName} ${statusText}`,
+                                message: evt.error || (evt.status === 'ok' ? 'Task completed successfully.' : 'Task did not complete.'),
+                                taskId: evt.taskId,
+                                cronJobId: evt.jobId,
+                                workspaceId: job?.workspaceId,
+                            });
+                        }
+                        catch (err) {
+                            console.error('[Cron] Failed to add in-app notification:', err);
+                        }
+                    }
+                    // Show macOS notification
+                    if (electron_1.Notification.isSupported()) {
+                        const notification = new electron_1.Notification({
+                            title: `${statusEmoji} Scheduled Task ${statusText}`,
+                            body: evt.error ? `Error: ${evt.error}` : 'Click to view results in the app.',
+                            silent: false,
+                        });
+                        notification.on('click', () => {
+                            // Bring the main window to focus
+                            if (mainWindow) {
+                                if (mainWindow.isMinimized())
+                                    mainWindow.restore();
+                                mainWindow.focus();
+                            }
+                        });
+                        notification.show();
+                    }
+                }
+            },
+            log: {
+                debug: (msg, data) => console.log(`[Cron] ${msg}`, data ?? ''),
+                info: (msg, data) => console.log(`[Cron] ${msg}`, data ?? ''),
+                warn: (msg, data) => console.warn(`[Cron] ${msg}`, data ?? ''),
+                error: (msg, data) => console.error(`[Cron] ${msg}`, data ?? ''),
+            },
+        });
+        (0, cron_1.setCronService)(cronService);
+        await cronService.start();
+        console.log('[Main] Cron Service initialized');
+    }
+    catch (error) {
+        console.error('[Main] Failed to initialize Cron Service:', error);
+        // Don't fail app startup if cron init fails
+    }
+    // Initialize channel gateway with agent daemon for task processing
+    channelGateway = new gateway_1.ChannelGateway(dbManager.getDatabase(), {
+        autoConnect: true, // Auto-connect enabled channels on startup
+        agentDaemon,
+    });
+    // Setup IPC handlers
+    await (0, handlers_1.setupIpcHandlers)(dbManager, agentDaemon, channelGateway);
+    // Initialize Mission Control services
+    try {
+        const db = dbManager.getDatabase();
+        const agentRoleRepo = new AgentRoleRepository_1.AgentRoleRepository(db);
+        // Sync any new default agents to existing workspaces
+        const addedAgents = agentRoleRepo.syncNewDefaults();
+        if (addedAgents.length > 0) {
+            console.log(`[Main] Added ${addedAgents.length} new default agent(s)`);
+        }
+        const mentionRepo = new MentionRepository_1.MentionRepository(db);
+        const activityRepo = new ActivityRepository_1.ActivityRepository(db);
+        const workingStateRepo = new WorkingStateRepository_1.WorkingStateRepository(db);
+        const taskSubscriptionRepo = new TaskSubscriptionRepository_1.TaskSubscriptionRepository(db);
+        const standupService = new StandupReportService_1.StandupReportService(db);
+        // Create repositories for heartbeat service
+        const taskRepo = new repositories_1.TaskRepository(db);
+        const workspaceRepo = new repositories_1.WorkspaceRepository(db);
+        // Initialize HeartbeatService with dependencies
+        const heartbeatDeps = {
+            agentRoleRepo,
+            mentionRepo,
+            activityRepo,
+            workingStateRepo,
+            createTask: async (workspaceId, prompt, title, _agentRoleId) => {
+                // Create task via agentDaemon (doesn't support assignedAgentRoleId directly)
+                const task = await agentDaemon.createTask({
+                    title,
+                    prompt,
+                    workspaceId,
+                });
+                // Note: Task assignment would need to be done separately if needed
+                return task;
+            },
+            getTasksForAgent: (agentRoleId, workspaceId) => {
+                // Get assigned tasks for the agent using the task repository
+                const tasks = workspaceId
+                    ? taskRepo.findByWorkspace(workspaceId)
+                    : taskRepo.findByStatus(['pending', 'running']);
+                return tasks.filter((t) => t.assignedAgentRoleId === agentRoleId);
+            },
+            getDefaultWorkspaceId: () => {
+                // Get the first workspace as default
+                const workspaces = workspaceRepo.findAll();
+                return workspaces[0]?.id;
+            },
+        };
+        const heartbeatService = new HeartbeatService_1.HeartbeatService(heartbeatDeps);
+        await heartbeatService.start();
+        // Setup Mission Control IPC handlers
+        (0, mission_control_handlers_1.setupMissionControlHandlers)({
+            agentRoleRepo,
+            taskSubscriptionRepo,
+            standupService,
+            heartbeatService,
+            getMainWindow: () => mainWindow,
+        });
+        console.log('[Main] Mission Control services initialized');
+    }
+    catch (error) {
+        console.error('[Main] Failed to initialize Mission Control:', error);
+        // Don't fail app startup if Mission Control init fails
+    }
+    // Register canvas:// protocol handler (must be after app.ready)
+    (0, canvas_1.registerCanvasProtocol)();
+    // Create window
+    createWindow();
+    // Initialize gateway with main window reference
+    if (mainWindow) {
+        await channelGateway.initialize(mainWindow);
+        // Initialize update manager with main window reference
+        updater_1.updateManager.setMainWindow(mainWindow);
+        // Initialize Live Canvas handlers and set main window reference
+        (0, canvas_handlers_1.setupCanvasHandlers)(mainWindow, agentDaemon);
+        canvas_1.CanvasManager.getInstance().setMainWindow(mainWindow);
+        // Restore persisted canvas sessions from disk
+        await canvas_1.CanvasManager.getInstance().restoreSessions();
+        // Initialize control plane (WebSocket gateway)
+        (0, control_plane_1.setupControlPlaneHandlers)(mainWindow);
+        // Initialize menu bar tray (macOS native companion)
+        if (process.platform === 'darwin') {
+            await tray_1.trayManager.initialize(mainWindow, channelGateway, dbManager, agentDaemon);
+        }
+        // Show migration notification after window is ready
+        if (migrationResult.migrated && migrationResult.migratedKeys.length > 0) {
+            mainWindow.webContents.once('did-finish-load', () => {
+                electron_1.dialog.showMessageBox(mainWindow, {
+                    type: 'info',
+                    title: 'Configuration Migrated',
+                    message: 'Your API credentials have been migrated',
+                    detail: `The following credentials were migrated from your .env file to secure Settings storage:\n\n` +
+                        `${migrationResult.migratedKeys.map(k => `• ${k}`).join('\n')}\n\n` +
+                        `Your .env file has been renamed to .env.migrated. ` +
+                        `You can safely delete it after verifying your settings work correctly.\n\n` +
+                        `Open Settings (gear icon) to review your configuration.`,
+                    buttons: ['OK'],
+                });
+            });
+        }
+    }
+    electron_1.app.on('activate', () => {
+        if (electron_1.BrowserWindow.getAllWindows().length === 0) {
+            createWindow();
+        }
+    });
+});
+electron_1.app.on('window-all-closed', () => {
+    if (process.platform !== 'darwin') {
+        electron_1.app.quit();
+    }
+});
+electron_1.app.on('before-quit', async () => {
+    // Destroy tray
+    tray_1.trayManager.destroy();
+    // Stop cron service (async to properly shutdown webhook server)
+    if (cronService) {
+        await cronService.stop();
+        (0, cron_1.setCronService)(null);
+    }
+    // Cleanup canvas manager (close all windows and watchers)
+    await (0, canvas_handlers_1.cleanupCanvasHandlers)();
+    // Shutdown control plane (WebSocket gateway and Tailscale)
+    await (0, control_plane_1.shutdownControlPlane)();
+    if (channelGateway) {
+        await channelGateway.shutdown();
+    }
+    // Disconnect all MCP servers
+    try {
+        const mcpClientManager = MCPClientManager_1.MCPClientManager.getInstance();
+        await mcpClientManager.shutdown();
+    }
+    catch (error) {
+        console.error('[Main] Failed to shutdown MCP servers:', error);
+    }
+    // Shutdown Memory Service
+    try {
+        MemoryService_1.MemoryService.shutdown();
+    }
+    catch (error) {
+        console.error('[Main] Failed to shutdown Memory Service:', error);
+    }
+    if (dbManager) {
+        dbManager.close();
+    }
+    if (agentDaemon) {
+        agentDaemon.shutdown();
+    }
+});
+// Handle folder selection
+electron_1.ipcMain.handle('dialog:selectFolder', async () => {
+    const result = await electron_1.dialog.showOpenDialog({
+        properties: ['openDirectory'],
+        title: 'Select Workspace Folder',
+    });
+    if (!result.canceled && result.filePaths.length > 0) {
+        return result.filePaths[0];
+    }
+    return null;
+});