codex-linux 1.0.0

package/dist/main/main.js

@@ -0,0 +1,1087 @@
+"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;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs/promises"));
+const child_process_1 = require("child_process");
+const electron_log_1 = __importDefault(require("electron-log"));
+const electron_store_1 = __importDefault(require("electron-store"));
+const electron_updater_1 = require("electron-updater");
+const AgentOrchestrator_1 = require("./agents/AgentOrchestrator");
+const GitWorktreeManager_1 = require("./git/GitWorktreeManager");
+const SkillsManager_1 = require("./skills/SkillsManager");
+const AutomationScheduler_1 = require("./automations/AutomationScheduler");
+const DatabaseManager_1 = require("./DatabaseManager");
+const SettingsManager_1 = require("./SettingsManager");
+const AIProviderManager_1 = require("./providers/AIProviderManager");
+const SecurityManager_1 = require("./security/SecurityManager");
+const AuditLogger_1 = require("./security/AuditLogger");
+const BackupManager_1 = require("./backup/BackupManager");
+const MigrationManager_1 = require("./backup/MigrationManager");
+const APIServer_1 = require("./api/APIServer");
+const PluginManager_1 = require("./plugins/PluginManager");
+const CoworkManager_1 = require("./cowork/CoworkManager");
+const GitHubPRMonitor_1 = require("./github/GitHubPRMonitor");
+const MCPManager_1 = require("./mcp/MCPManager");
+const AIPairProgramming_1 = require("./pair/AIPairProgramming");
+const ErrorTracker_1 = require("./monitoring/ErrorTracker");
+const MetricsCollector_1 = require("./monitoring/MetricsCollector");
+const NotificationManager_1 = require("./notifications/NotificationManager");
+const SmartCodeAssistant_1 = require("./assistant/SmartCodeAssistant");
+const zod_1 = require("zod");
+// Validation schemas
+const AgentConfigSchema = zod_1.z.object({
+    name: zod_1.z.string().min(1).max(100),
+    projectPath: zod_1.z.string().min(1),
+    providerId: zod_1.z.string(),
+    model: zod_1.z.string(),
+    skills: zod_1.z.array(zod_1.z.string()).optional(),
+    systemPrompt: zod_1.z.string().optional(),
+}).strict();
+const store = new electron_store_1.default();
+let mainWindow = null;
+let agentOrchestrator;
+let gitWorktreeManager;
+let skillsManager;
+let automationScheduler;
+let dbManager;
+let settingsManager;
+let aiProviderManager;
+let securityManager;
+let auditLogger;
+let backupManager;
+let migrationManager;
+let apiServer;
+let pluginManager;
+let coworkManager;
+let githubPRMonitor;
+let mcpManager;
+let aiPairProgramming;
+let errorTracker;
+let notificationManager;
+let smartCodeAssistant;
+electron_log_1.default.info('Starting Codex Linux...');
+function createWindow() {
+    mainWindow = new electron_1.BrowserWindow({
+        width: 1600,
+        height: 1000,
+        minWidth: 1200,
+        minHeight: 800,
+        titleBarStyle: 'hiddenInset',
+        webPreferences: {
+            nodeIntegration: false,
+            contextIsolation: true,
+            preload: path.join(__dirname, 'preload.js'),
+            sandbox: false
+        },
+        show: false,
+        icon: path.join(__dirname, '../../assets/icon.png')
+    });
+    if (process.env.VITE_DEV_SERVER_URL) {
+        mainWindow.loadURL(process.env.VITE_DEV_SERVER_URL);
+        mainWindow.webContents.openDevTools();
+    }
+    else {
+        mainWindow.loadFile(path.join(__dirname, '../renderer/index.html'));
+    }
+    mainWindow.once('ready-to-show', () => {
+        mainWindow?.show();
+    });
+    mainWindow.on('closed', () => {
+        mainWindow = null;
+    });
+}
+let tray = null;
+function createTray() {
+    const iconPath = path.join(__dirname, '../../assets/icon.png');
+    try {
+        const icon = electron_1.nativeImage.createFromPath(iconPath);
+        tray = new electron_1.Tray(icon.isEmpty() ? electron_1.nativeImage.createEmpty() : icon);
+        const contextMenu = electron_1.Menu.buildFromTemplate([
+            {
+                label: 'Show Codex',
+                click: () => {
+                    if (mainWindow) {
+                        mainWindow.show();
+                        mainWindow.focus();
+                    }
+                }
+            },
+            { type: 'separator' },
+            {
+                label: 'New Agent',
+                click: () => {
+                    if (mainWindow) {
+                        mainWindow.show();
+                        mainWindow.webContents.send('create-new-agent');
+                    }
+                }
+            },
+            {
+                label: 'Open Settings',
+                click: () => {
+                    if (mainWindow) {
+                        mainWindow.show();
+                        mainWindow.webContents.send('open-settings');
+                    }
+                }
+            },
+            { type: 'separator' },
+            {
+                label: 'Quit',
+                click: () => {
+                    electron_1.app.quit();
+                }
+            }
+        ]);
+        tray.setToolTip('Codex Linux');
+        tray.setContextMenu(contextMenu);
+        tray.on('click', () => {
+            if (mainWindow) {
+                if (mainWindow.isVisible()) {
+                    mainWindow.hide();
+                }
+                else {
+                    mainWindow.show();
+                    mainWindow.focus();
+                }
+            }
+        });
+        electron_log_1.default.info('System tray initialized');
+    }
+    catch (error) {
+        electron_log_1.default.warn('Failed to create system tray:', error);
+    }
+}
+function registerGlobalShortcuts() {
+    try {
+        electron_1.globalShortcut.register('CommandOrControl+Shift+C', () => {
+            if (mainWindow) {
+                if (mainWindow.isVisible()) {
+                    mainWindow.hide();
+                }
+                else {
+                    mainWindow.show();
+                    mainWindow.focus();
+                }
+            }
+        });
+        electron_1.globalShortcut.register('CommandOrControl+Shift+N', () => {
+            if (mainWindow) {
+                mainWindow.show();
+                mainWindow.webContents.send('create-new-agent');
+            }
+        });
+        electron_1.globalShortcut.register('CommandOrControl+Shift+K', () => {
+            if (mainWindow) {
+                mainWindow.show();
+                mainWindow.webContents.send('open-search');
+            }
+        });
+        electron_log_1.default.info('Global shortcuts registered');
+    }
+    catch (error) {
+        electron_log_1.default.warn('Failed to register global shortcuts:', error);
+    }
+}
+async function initializeServices() {
+    try {
+        // Initialize security first
+        securityManager = new SecurityManager_1.SecurityManager();
+        await securityManager.initialize();
+        electron_log_1.default.info('Security manager initialized');
+        // Initialize database
+        dbManager = new DatabaseManager_1.DatabaseManager();
+        await dbManager.initialize();
+        electron_log_1.default.info('Database initialized');
+        // Run migrations
+        migrationManager = new MigrationManager_1.MigrationManager(dbManager);
+        await migrationManager.initialize();
+        electron_log_1.default.info('Migrations completed');
+        // Initialize settings
+        settingsManager = new SettingsManager_1.SettingsManager(store);
+        electron_log_1.default.info('Settings manager initialized');
+        // Initialize AI provider manager
+        aiProviderManager = new AIProviderManager_1.AIProviderManager(settingsManager);
+        electron_log_1.default.info('AI provider manager initialized');
+        // Initialize notification manager
+        notificationManager = new NotificationManager_1.NotificationManager();
+        electron_log_1.default.info('Notification manager initialized');
+        // Initialize Git worktree manager
+        gitWorktreeManager = new GitWorktreeManager_1.GitWorktreeManager();
+        electron_log_1.default.info('Git worktree manager initialized');
+        // Initialize skills manager
+        skillsManager = new SkillsManager_1.SkillsManager();
+        await skillsManager.initialize();
+        electron_log_1.default.info('Skills manager initialized');
+        // Initialize automation scheduler
+        automationScheduler = new AutomationScheduler_1.AutomationScheduler();
+        automationScheduler.setNotificationManager(notificationManager);
+        await automationScheduler.initialize();
+        electron_log_1.default.info('Automation scheduler initialized');
+        // Initialize agent orchestrator
+        agentOrchestrator = new AgentOrchestrator_1.AgentOrchestrator(aiProviderManager, gitWorktreeManager, skillsManager, dbManager);
+        await agentOrchestrator.initialize();
+        electron_log_1.default.info('Agent orchestrator initialized');
+        agentOrchestrator.on('changes:created', (payload) => {
+            if (mainWindow) {
+                mainWindow.webContents.send('changes:created', payload);
+            }
+        });
+        agentOrchestrator.on('agent:taskCompleted', (payload) => {
+            if (mainWindow) {
+                mainWindow.webContents.send('agent:taskCompleted', payload);
+            }
+        });
+        agentOrchestrator.on('agent:taskStarted', (payload) => {
+            if (mainWindow) {
+                mainWindow.webContents.send('agent:taskStarted', payload);
+            }
+        });
+        agentOrchestrator.on('agent:taskFailed', (payload) => {
+            if (mainWindow) {
+                mainWindow.webContents.send('agent:taskFailed', payload);
+            }
+        });
+        agentOrchestrator.on('agent:paused', (payload) => {
+            if (mainWindow) {
+                mainWindow.webContents.send('agent:paused', payload);
+            }
+        });
+        agentOrchestrator.on('agent:resumed', (payload) => {
+            if (mainWindow) {
+                mainWindow.webContents.send('agent:resumed', payload);
+            }
+        });
+        agentOrchestrator.on('agent:stopped', (payload) => {
+            if (mainWindow) {
+                mainWindow.webContents.send('agent:stopped', payload);
+            }
+        });
+        // Initialize backup manager
+        backupManager = new BackupManager_1.BackupManager();
+        await backupManager.initialize();
+        electron_log_1.default.info('Backup manager initialized');
+        // Initialize plugin manager
+        pluginManager = new PluginManager_1.PluginManager();
+        await pluginManager.initialize();
+        electron_log_1.default.info('Plugin manager initialized');
+        // Initialize cowork manager
+        coworkManager = new CoworkManager_1.CoworkManager(agentOrchestrator, dbManager, notificationManager);
+        await coworkManager.initialize();
+        electron_log_1.default.info('Cowork manager initialized');
+        // Initialize AI pair programming
+        aiPairProgramming = new AIPairProgramming_1.AIPairProgramming(agentOrchestrator, aiProviderManager);
+        electron_log_1.default.info('AI pair programming initialized');
+        // Initialize smart code assistant
+        smartCodeAssistant = new SmartCodeAssistant_1.SmartCodeAssistant(aiProviderManager);
+        electron_log_1.default.info('Smart code assistant initialized');
+        // Initialize MCP manager
+        mcpManager = new MCPManager_1.MCPManager();
+        await mcpManager.initialize();
+        electron_log_1.default.info('MCP manager initialized');
+        // Initialize audit logger
+        auditLogger = new AuditLogger_1.AuditLogger();
+        await auditLogger.initialize();
+        electron_log_1.default.info('Audit logger initialized');
+        const sentryDsn = settingsManager.get('sentryDsn');
+        if (sentryDsn) {
+            errorTracker = new ErrorTracker_1.ErrorTracker();
+            errorTracker.initialize(sentryDsn);
+            electron_log_1.default.info('Error tracker initialized');
+        }
+        // Start system metrics
+        (0, MetricsCollector_1.startSystemMetrics)();
+        electron_log_1.default.info('System metrics started');
+        // Initialize API server
+        apiServer = new APIServer_1.APIServer(agentOrchestrator, securityManager, auditLogger);
+        await apiServer.start();
+        electron_log_1.default.info('API server started on port 3001');
+        // Initialize GitHub PR Monitor if token available
+        const githubToken = settingsManager.get('githubToken');
+        if (githubToken) {
+            githubPRMonitor = new GitHubPRMonitor_1.GitHubPRMonitor(githubToken, agentOrchestrator, gitWorktreeManager, notificationManager);
+            await githubPRMonitor.initialize();
+            electron_log_1.default.info('GitHub PR monitor initialized');
+        }
+    }
+    catch (error) {
+        electron_log_1.default.error('Failed to initialize services:', error);
+        throw error;
+    }
+}
+// App event handlers
+electron_1.app.whenReady().then(async () => {
+    try {
+        await initializeServices();
+        createWindow();
+        createTray();
+        registerGlobalShortcuts();
+        setupIPC();
+        setupAutoUpdater();
+        setupAutoUpdaterIPC();
+        electron_1.app.on('activate', () => {
+            if (electron_1.BrowserWindow.getAllWindows().length === 0) {
+                createWindow();
+            }
+        });
+    }
+    catch (error) {
+        electron_log_1.default.error('Failed to start application:', error);
+        electron_1.dialog.showErrorBox('Startup Error', 'Failed to initialize Codex Linux. Please check the logs.');
+        electron_1.app.quit();
+    }
+});
+electron_1.app.on('window-all-closed', () => {
+    if (process.platform !== 'darwin') {
+        electron_1.app.quit();
+    }
+});
+electron_1.app.on('before-quit', async () => {
+    await cleanup();
+});
+function setupAutoUpdater() {
+    if (electron_1.app.isPackaged) {
+        electron_updater_1.autoUpdater.logger = electron_log_1.default;
+        electron_updater_1.autoUpdater.autoDownload = true;
+        electron_updater_1.autoUpdater.autoInstallOnAppQuit = true;
+        electron_updater_1.autoUpdater.on('checking-for-update', () => {
+            electron_log_1.default.info('Checking for updates...');
+        });
+        electron_updater_1.autoUpdater.on('update-available', (info) => {
+            electron_log_1.default.info('Update available:', info.version);
+            if (mainWindow) {
+                mainWindow.webContents.send('update-available', info);
+            }
+        });
+        electron_updater_1.autoUpdater.on('update-not-available', () => {
+            electron_log_1.default.info('No updates available');
+        });
+        electron_updater_1.autoUpdater.on('download-progress', (progress) => {
+            electron_log_1.default.info(`Download progress: ${progress.percent}%`);
+            if (mainWindow) {
+                mainWindow.webContents.send('update-progress', progress);
+            }
+        });
+        electron_updater_1.autoUpdater.on('update-downloaded', (info) => {
+            electron_log_1.default.info('Update downloaded:', info.version);
+            if (mainWindow) {
+                mainWindow.webContents.send('update-downloaded', info);
+            }
+            if (electron_1.Notification.isSupported()) {
+                new electron_1.Notification({
+                    title: 'Update Ready',
+                    body: `Codex Linux ${info.version} is ready to install. Restart to update.`
+                }).show();
+            }
+        });
+        electron_updater_1.autoUpdater.on('error', (error) => {
+            electron_log_1.default.error('Auto-updater error:', error);
+        });
+        electron_updater_1.autoUpdater.checkForUpdatesAndNotify().catch(err => {
+            electron_log_1.default.warn('Failed to check for updates:', err);
+        });
+    }
+}
+function setupAutoUpdaterIPC() {
+    electron_1.ipcMain.handle('update:check', async () => {
+        if (!electron_1.app.isPackaged) {
+            return { available: false, message: 'Updates only work in packaged app' };
+        }
+        try {
+            const result = await electron_updater_1.autoUpdater.checkForUpdates();
+            return { available: !!result?.updateInfo, version: result?.updateInfo?.version };
+        }
+        catch (error) {
+            electron_log_1.default.error('Update check failed:', error);
+            return { available: false, message: 'Update check failed' };
+        }
+    });
+    electron_1.ipcMain.handle('update:download', async () => {
+        if (!electron_1.app.isPackaged) {
+            return { success: false, message: 'Updates only work in packaged app' };
+        }
+        try {
+            await electron_updater_1.autoUpdater.downloadUpdate();
+            return { success: true };
+        }
+        catch (error) {
+            electron_log_1.default.error('Update download failed:', error);
+            return { success: false, message: 'Update download failed' };
+        }
+    });
+    electron_1.ipcMain.handle('update:install', () => {
+        electron_updater_1.autoUpdater.quitAndInstall(false, true);
+    });
+}
+async function cleanup() {
+    electron_log_1.default.info('Starting cleanup...');
+    try {
+        electron_1.globalShortcut.unregisterAll();
+        tray?.destroy();
+        tray = null;
+        if (agentOrchestrator) {
+            agentOrchestrator.removeAllListeners('changes:created');
+            agentOrchestrator.removeAllListeners('agent:taskCompleted');
+            agentOrchestrator.removeAllListeners('agent:taskStarted');
+            agentOrchestrator.removeAllListeners('agent:taskFailed');
+            agentOrchestrator.removeAllListeners('agent:paused');
+            agentOrchestrator.removeAllListeners('agent:resumed');
+            agentOrchestrator.removeAllListeners('agent:stopped');
+        }
+        await Promise.all([
+            agentOrchestrator?.cleanup(),
+            automationScheduler?.cleanup(),
+            coworkManager?.cleanup(),
+            apiServer?.stop(),
+            pluginManager?.cleanup(),
+            mcpManager?.cleanup(),
+            githubPRMonitor?.cleanup(),
+            backupManager?.cleanup?.(),
+            auditLogger?.cleanup?.(),
+            dbManager?.close()
+        ]);
+        electron_log_1.default.info('Cleanup completed');
+    }
+    catch (error) {
+        electron_log_1.default.error('Error during cleanup:', error);
+    }
+}
+function setupIPC() {
+    // Window controls
+    electron_1.ipcMain.handle('window:minimize', () => {
+        mainWindow?.minimize();
+    });
+    electron_1.ipcMain.handle('window:maximize', () => {
+        if (mainWindow?.isMaximized()) {
+            mainWindow.unmaximize();
+        }
+        else {
+            mainWindow?.maximize();
+        }
+    });
+    electron_1.ipcMain.handle('window:close', () => {
+        mainWindow?.close();
+    });
+    // File system operations
+    electron_1.ipcMain.handle('dialog:selectFolder', async () => {
+        if (!mainWindow) {
+            throw new Error('No main window available');
+        }
+        const result = await electron_1.dialog.showOpenDialog(mainWindow, {
+            properties: ['openDirectory']
+        });
+        return result.filePaths[0] || null;
+    });
+    electron_1.ipcMain.handle('dialog:selectFile', async (event, filters) => {
+        if (!mainWindow) {
+            throw new Error('No main window available');
+        }
+        const result = await electron_1.dialog.showOpenDialog(mainWindow, {
+            properties: ['openFile'],
+            filters
+        });
+        return result.filePaths[0] || null;
+    });
+    electron_1.ipcMain.handle('shell:openExternal', (event, url) => {
+        electron_1.shell.openExternal(url);
+    });
+    electron_1.ipcMain.handle('shell:openPath', (event, path) => {
+        electron_1.shell.openPath(path);
+    });
+    // Agent operations with validation
+    electron_1.ipcMain.handle('agent:create', async (event, config) => {
+        try {
+            const validatedConfig = AgentConfigSchema.parse(config);
+            const result = await agentOrchestrator.createAgent(validatedConfig);
+            await auditLogger.log('agent_created', { agentId: result.id });
+            return result;
+        }
+        catch (error) {
+            electron_log_1.default.error('Failed to create agent:', error);
+            throw error;
+        }
+    });
+    electron_1.ipcMain.handle('agent:list', async () => {
+        return await agentOrchestrator.listAgents();
+    });
+    electron_1.ipcMain.handle('agent:get', async (event, agentId) => {
+        return await agentOrchestrator.getAgent(agentId);
+    });
+    electron_1.ipcMain.handle('agent:sendMessage', async (event, agentId, message) => {
+        try {
+            return await agentOrchestrator.sendMessage(agentId, message);
+        }
+        catch (error) {
+            electron_log_1.default.error('Failed to send message:', error);
+            throw error;
+        }
+    });
+    electron_1.ipcMain.handle('agent:sendMessageStream', async (event, agentId, message) => {
+        try {
+            const stream = await agentOrchestrator.sendMessageStream(agentId, message, {
+                onChunk: (chunk) => {
+                    event.sender.send('agent:streamChunk', { agentId, chunk });
+                },
+                onComplete: () => {
+                    event.sender.send('agent:streamEnd', { agentId });
+                },
+                onError: (error) => {
+                    event.sender.send('agent:streamError', { agentId, error: error.message });
+                }
+            });
+            return { success: true };
+        }
+        catch (error) {
+            electron_log_1.default.error('Failed to start stream:', error);
+            throw error;
+        }
+    });
+    electron_1.ipcMain.handle('agent:executeTask', async (event, agentId, task) => {
+        return await agentOrchestrator.executeTask(agentId, task);
+    });
+    electron_1.ipcMain.handle('agent:pause', async (event, agentId) => {
+        return await agentOrchestrator.pauseAgent(agentId);
+    });
+    electron_1.ipcMain.handle('agent:resume', async (event, agentId) => {
+        return await agentOrchestrator.resumeAgent(agentId);
+    });
+    electron_1.ipcMain.handle('agent:stop', async (event, agentId) => {
+        return await agentOrchestrator.stopAgent(agentId);
+    });
+    electron_1.ipcMain.handle('agent:delete', async (event, agentId) => {
+        try {
+            await agentOrchestrator.deleteAgent(agentId);
+            await auditLogger.log('agent_deleted', { agentId });
+            return { success: true };
+        }
+        catch (error) {
+            electron_log_1.default.error('Failed to delete agent:', error);
+            throw error;
+        }
+    });
+    // Worktree operations
+    electron_1.ipcMain.handle('worktree:create', async (event, repoPath, name) => {
+        return await gitWorktreeManager.createWorktree(repoPath, name);
+    });
+    electron_1.ipcMain.handle('worktree:list', async (event, repoPath) => {
+        return await gitWorktreeManager.listWorktrees(repoPath);
+    });
+    electron_1.ipcMain.handle('worktree:remove', async (event, repoPath, name) => {
+        return await gitWorktreeManager.removeWorktree(repoPath, name);
+    });
+    // Skills operations
+    electron_1.ipcMain.handle('skills:list', async () => {
+        return await skillsManager.listSkills();
+    });
+    electron_1.ipcMain.handle('skills:get', async (event, skillId) => {
+        return await skillsManager.getSkill(skillId);
+    });
+    electron_1.ipcMain.handle('skills:create', async (event, skillConfig) => {
+        return await skillsManager.createSkill(skillConfig);
+    });
+    electron_1.ipcMain.handle('skills:update', async (event, skillId, skillConfig) => {
+        return await skillsManager.updateSkill(skillId, skillConfig);
+    });
+    electron_1.ipcMain.handle('skills:delete', async (event, skillId) => {
+        return await skillsManager.deleteSkill(skillId);
+    });
+    electron_1.ipcMain.handle('skills:applyToAgent', async (event, agentId, skillIds) => {
+        return await agentOrchestrator.applySkills(agentId, skillIds);
+    });
+    // Automation operations
+    electron_1.ipcMain.handle('automation:list', async () => {
+        return await automationScheduler.listAutomations();
+    });
+    electron_1.ipcMain.handle('automation:create', async (event, config) => {
+        return await automationScheduler.createAutomation(config);
+    });
+    electron_1.ipcMain.handle('automation:update', async (event, automationId, config) => {
+        return await automationScheduler.updateAutomation(automationId, config);
+    });
+    electron_1.ipcMain.handle('automation:delete', async (event, automationId) => {
+        return await automationScheduler.deleteAutomation(automationId);
+    });
+    electron_1.ipcMain.handle('automation:toggle', async (event, automationId, enabled) => {
+        return await automationScheduler.toggleAutomation(automationId, enabled);
+    });
+    // Settings operations
+    electron_1.ipcMain.handle('settings:get', (event, key) => {
+        return settingsManager.getAny(key);
+    });
+    electron_1.ipcMain.handle('settings:set', (event, key, value) => {
+        settingsManager.setAny(key, value);
+    });
+    electron_1.ipcMain.handle('settings:getAll', () => {
+        return settingsManager.getAll();
+    });
+    // AI Provider operations
+    electron_1.ipcMain.handle('providers:list', () => {
+        return aiProviderManager.listProviders();
+    });
+    electron_1.ipcMain.handle('providers:getActive', () => {
+        return aiProviderManager.getActiveProvider();
+    });
+    electron_1.ipcMain.handle('providers:setActive', (event, providerId) => {
+        return aiProviderManager.setActiveProvider(providerId);
+    });
+    electron_1.ipcMain.handle('providers:configure', (event, providerId, config) => {
+        return aiProviderManager.configureProvider(providerId, config);
+    });
+    electron_1.ipcMain.handle('providers:test', async (event, providerId) => {
+        return await aiProviderManager.testProvider(providerId);
+    });
+    // File system operations
+    electron_1.ipcMain.handle('fs:readdir', async (event, dirPath, options) => {
+        try {
+            const normalizedPath = path.normalize(dirPath);
+            if (normalizedPath.includes('..')) {
+                throw new Error('Path traversal not allowed');
+            }
+            const entries = await fs.readdir(normalizedPath, { withFileTypes: true });
+            return entries.map((entry) => ({
+                name: entry.name,
+                isDirectory: entry.isDirectory(),
+                isFile: entry.isFile()
+            }));
+        }
+        catch (error) {
+            electron_log_1.default.error('Failed to read directory:', error);
+            throw error;
+        }
+    });
+    electron_1.ipcMain.handle('fs:readFile', async (event, filePath, encoding) => {
+        try {
+            const normalizedPath = path.normalize(filePath);
+            if (normalizedPath.includes('..')) {
+                throw new Error('Path traversal not allowed');
+            }
+            const content = await fs.readFile(normalizedPath, encoding || 'utf-8');
+            return content;
+        }
+        catch (error) {
+            electron_log_1.default.error('Failed to read file:', error);
+            throw error;
+        }
+    });
+    electron_1.ipcMain.handle('fs:writeFile', async (event, filePath, content) => {
+        if (!filePath || typeof filePath !== 'string') {
+            throw new Error('File path is required');
+        }
+        const normalizedPath = path.normalize(filePath);
+        if (normalizedPath.includes('..') || normalizedPath.startsWith('/etc') || normalizedPath.startsWith('/root') || normalizedPath.startsWith('/sys') || normalizedPath.startsWith('/proc')) {
+            throw new Error('Path traversal or restricted path not allowed');
+        }
+        try {
+            await fs.writeFile(normalizedPath, content, 'utf-8');
+        }
+        catch (error) {
+            electron_log_1.default.error('Failed to write file:', error);
+            throw error;
+        }
+    });
+    electron_1.ipcMain.handle('fs:stat', async (event, filePath) => {
+        try {
+            const normalizedPath = path.normalize(filePath);
+            if (normalizedPath.includes('..')) {
+                throw new Error('Path traversal not allowed');
+            }
+            const stats = await fs.stat(normalizedPath);
+            return {
+                isFile: stats.isFile(),
+                isDirectory: stats.isDirectory(),
+                size: stats.size,
+                mtime: stats.mtime,
+                ctime: stats.ctime
+            };
+        }
+        catch (error) {
+            electron_log_1.default.error('Failed to stat file:', error);
+            throw error;
+        }
+    });
+    // Terminal operations
+    const ALLOWED_COMMANDS = new Set([
+        'npm', 'node', 'pnpm', 'yarn', 'bun', 'deno',
+        'git', 'docker', 'docker-compose', 'kubectl',
+        'python', 'python3', 'pip', 'pip3',
+        'make', 'cmake', 'gcc', 'g++', 'clang', 'rustc',
+        'cargo', 'go', 'java', 'javac', 'gradle', 'maven',
+        'ls', 'cat', 'grep', 'find', 'chmod', 'chown', 'mkdir', 'rm', 'rmdir', 'cp', 'mv', 'touch',
+        'code', 'codex', 'opencode'
+    ]);
+    const terminalProcesses = new Map();
+    let terminalIdCounter = 0;
+    function parseCommandLine(command) {
+        const args = [];
+        let current = '';
+        let inQuote = false;
+        let quoteChar = '';
+        for (let i = 0; i < command.length; i++) {
+            const char = command[i];
+            if ((char === '"' || char === "'") && !inQuote) {
+                inQuote = true;
+                quoteChar = char;
+            }
+            else if (char === quoteChar && inQuote) {
+                inQuote = false;
+                quoteChar = '';
+            }
+            else if (char === ' ' && !inQuote) {
+                if (current) {
+                    args.push(current);
+                    current = '';
+                }
+            }
+            else {
+                current += char;
+            }
+        }
+        if (current)
+            args.push(current);
+        return args;
+    }
+    electron_1.ipcMain.handle('terminal:execute', async (event, { command, cwd }) => {
+        if (!command || typeof command !== 'string') {
+            throw new Error('Command is required');
+        }
+        if (!cwd || typeof cwd !== 'string') {
+            throw new Error('CWD is required');
+        }
+        const parsedArgs = parseCommandLine(command);
+        if (parsedArgs.length === 0) {
+            throw new Error('Command is required');
+        }
+        const cmd = parsedArgs[0];
+        const args = parsedArgs.slice(1);
+        if (!ALLOWED_COMMANDS.has(cmd)) {
+            throw new Error(`Command "${cmd}" is not allowed. Allowed commands: ${[...ALLOWED_COMMANDS].join(', ')}`);
+        }
+        const currentTerminalId = ++terminalIdCounter;
+        return new Promise((resolve) => {
+            const proc = (0, child_process_1.spawn)(cmd, args, {
+                cwd,
+                shell: false,
+                env: { ...process.env, FORCE_COLOR: '1' }
+            });
+            terminalProcesses.set(currentTerminalId, proc);
+            let stdout = '';
+            let stderr = '';
+            proc.stdout?.on('data', (data) => {
+                stdout += data.toString();
+            });
+            proc.stderr?.on('data', (data) => {
+                stderr += data.toString();
+            });
+            const cleanup = () => {
+                terminalProcesses.delete(currentTerminalId);
+            };
+            proc.on('close', (code) => {
+                cleanup();
+                resolve({
+                    stdout,
+                    stderr,
+                    exitCode: code,
+                    error: code !== 0 ? `Process exited with code ${code}` : null
+                });
+            });
+            proc.on('error', (error) => {
+                cleanup();
+                resolve({
+                    stdout,
+                    stderr,
+                    exitCode: -1,
+                    error: error.message
+                });
+            });
+        });
+    });
+    electron_1.ipcMain.handle('terminal:kill', () => {
+        for (const [id, proc] of terminalProcesses) {
+            proc.kill();
+            terminalProcesses.delete(id);
+        }
+    });
+    // Code changes operations
+    electron_1.ipcMain.handle('changes:list', async (event, agentId) => {
+        return await dbManager.getCodeChanges(agentId);
+    });
+    electron_1.ipcMain.handle('changes:approve', async (event, changeId) => {
+        return await dbManager.approveCodeChange(changeId);
+    });
+    electron_1.ipcMain.handle('changes:reject', async (event, changeId, comment) => {
+        return await dbManager.rejectCodeChange(changeId, comment);
+    });
+    electron_1.ipcMain.handle('changes:apply', async (event, changeId) => {
+        return await dbManager.applyCodeChange(changeId);
+    });
+    // Checkpoints operations
+    electron_1.ipcMain.handle('checkpoints:list', async (event, agentId) => {
+        return await dbManager.listCheckpoints(agentId);
+    });
+    electron_1.ipcMain.handle('checkpoints:restore', async (event, checkpointId) => {
+        return await dbManager.restoreCheckpoint(checkpointId);
+    });
+    electron_1.ipcMain.handle('checkpoints:restoreLast', async (event, agentId) => {
+        return await dbManager.restoreLastCheckpoint(agentId);
+    });
+    // Agent queue operations
+    electron_1.ipcMain.handle('queue:list', async (event, agentId) => {
+        return await dbManager.listAgentQueueItems(agentId);
+    });
+    electron_1.ipcMain.handle('queue:enqueue', async (event, agentId, type, content) => {
+        return await dbManager.enqueueAgentQueueItem(agentId, type, content);
+    });
+    electron_1.ipcMain.handle('queue:delete', async (event, agentId, itemId) => {
+        return await dbManager.deleteAgentQueueItem(agentId, itemId);
+    });
+    electron_1.ipcMain.handle('queue:moveUp', async (event, agentId, itemId) => {
+        return await dbManager.moveAgentQueueItemUp(agentId, itemId);
+    });
+    electron_1.ipcMain.handle('queue:claimNext', async (event, agentId) => {
+        return await dbManager.claimNextAgentQueueItem(agentId);
+    });
+    electron_1.ipcMain.handle('queue:complete', async (event, agentId, itemId, outcome, error) => {
+        return await dbManager.completeAgentQueueItem(agentId, itemId, outcome, error);
+    });
+    electron_1.ipcMain.handle('queue:history', async (event, agentId, limit) => {
+        return await dbManager.getQueueHistory(agentId, limit);
+    });
+    // Git operations
+    electron_1.ipcMain.handle('git:status', async (event, repoPath) => {
+        return await gitWorktreeManager.getChanges(repoPath);
+    });
+    electron_1.ipcMain.handle('git:commit', async (event, { repoPath, message, files }) => {
+        return await gitWorktreeManager.commitChanges(repoPath, message, files);
+    });
+    electron_1.ipcMain.handle('git:diff', async (event, { repoPath, filePath }) => {
+        return await gitWorktreeManager.getDiff(repoPath, filePath);
+    });
+    // Search operations
+    electron_1.ipcMain.handle('search:files', async (event, { query, path, pattern }) => {
+        try {
+            const results = [];
+            async function searchDir(dirPath) {
+                const entries = await fs.readdir(dirPath, { withFileTypes: true });
+                for (const entry of entries) {
+                    const fullPath = `${dirPath}/${entry.name}`;
+                    if (entry.isDirectory()) {
+                        if (!entry.name.startsWith('.') &&
+                            entry.name !== 'node_modules' &&
+                            entry.name !== 'dist' &&
+                            entry.name !== 'build') {
+                            await searchDir(fullPath);
+                        }
+                    }
+                    else if (entry.isFile()) {
+                        if (pattern && !entry.name.match(pattern))
+                            continue;
+                        try {
+                            const content = await fs.readFile(fullPath, 'utf-8');
+                            const lines = content.split('\n');
+                            const matches = [];
+                            lines.forEach((line, index) => {
+                                if (line.toLowerCase().includes(query.toLowerCase())) {
+                                    matches.push({ line: index + 1, content: line.trim() });
+                                }
+                            });
+                            if (matches.length > 0) {
+                                results.push({ path: fullPath, matches });
+                            }
+                        }
+                        catch {
+                            // Skip binary or unreadable files
+                        }
+                    }
+                }
+            }
+            await searchDir(path);
+            return results;
+        }
+        catch (error) {
+            electron_log_1.default.error('Search failed:', error);
+            throw error;
+        }
+    });
+    // Audit log operations
+    electron_1.ipcMain.handle('audit:recent', async (event, limit = 100) => {
+        return await auditLogger.getRecentEvents(limit);
+    });
+    electron_1.ipcMain.handle('audit:byAction', async (event, action, limit = 100) => {
+        return await auditLogger.getEventsByAction(action, limit);
+    });
+    electron_1.ipcMain.handle('audit:export', async (event, exportPath) => {
+        await auditLogger.exportLogs(exportPath);
+        return { success: true };
+    });
+    electron_1.ipcMain.handle('notification:show', (event, { title, body }) => {
+        if (electron_1.Notification.isSupported()) {
+            new electron_1.Notification({
+                title,
+                body,
+                icon: path.join(__dirname, '../../assets/icon.png')
+            }).show();
+        }
+    });
+    // Export/Import
+    electron_1.ipcMain.handle('data:export', async (event, exportPath) => {
+        try {
+            const data = {
+                agents: await dbManager.getAllAgents(),
+                automations: await automationScheduler.listAutomations(),
+                skills: await skillsManager.listSkills(),
+                settings: settingsManager.getAll(),
+                exportedAt: new Date().toISOString()
+            };
+            await fs.writeFile(exportPath, JSON.stringify(data, null, 2), 'utf-8');
+            return true;
+        }
+        catch (error) {
+            electron_log_1.default.error('Export failed:', error);
+            throw error;
+        }
+    });
+    electron_1.ipcMain.handle('data:import', async (event, importPath) => {
+        try {
+            const normalizedPath = path.normalize(importPath);
+            if (normalizedPath.includes('..')) {
+                throw new Error('Path traversal not allowed');
+            }
+            const content = await fs.readFile(normalizedPath, 'utf-8');
+            let data;
+            try {
+                data = JSON.parse(content);
+            }
+            catch {
+                throw new Error('Invalid JSON format');
+            }
+            if (!data || typeof data !== 'object') {
+                throw new Error('Invalid import data: must be an object');
+            }
+            if (data.agents) {
+                if (!Array.isArray(data.agents)) {
+                    throw new Error('Invalid import data: agents must be an array');
+                }
+                for (const agent of data.agents) {
+                    if (!agent.name || !agent.projectPath || typeof agent.name !== 'string' || typeof agent.projectPath !== 'string') {
+                        throw new Error('Invalid agent: name and projectPath are required strings');
+                    }
+                    if (agent.projectPath.includes('..') || agent.projectPath.startsWith('/etc') || agent.projectPath.startsWith('/root')) {
+                        throw new Error('Invalid agent projectPath: path traversal or restricted path not allowed');
+                    }
+                    await dbManager.createAgent(agent);
+                }
+            }
+            if (data.automations) {
+                if (!Array.isArray(data.automations)) {
+                    throw new Error('Invalid import data: automations must be an array');
+                }
+                for (const automation of data.automations) {
+                    if (!automation.name || !automation.trigger) {
+                        throw new Error('Invalid automation: name and trigger are required');
+                    }
+                    await automationScheduler.createAutomation(automation);
+                }
+            }
+            if (data.settings) {
+                if (typeof data.settings !== 'object' || Array.isArray(data.settings)) {
+                    throw new Error('Invalid import data: settings must be an object');
+                }
+                for (const [key, value] of Object.entries(data.settings)) {
+                    if (typeof key !== 'string') {
+                        throw new Error('Invalid settings: keys must be strings');
+                    }
+                    settingsManager.setAny(key, value);
+                }
+            }
+            return true;
+        }
+        catch (error) {
+            electron_log_1.default.error('Import failed:', error);
+            throw error;
+        }
+    });
+    // Cowork operations
+    electron_1.ipcMain.handle('cowork:create', async (event, name, objective, projectPath, options) => {
+        return await coworkManager.createSession(name, objective, projectPath, options);
+    });
+    electron_1.ipcMain.handle('cowork:start', async (event, sessionId) => {
+        return await coworkManager.startSession(sessionId);
+    });
+    electron_1.ipcMain.handle('cowork:pause', async (event, sessionId) => {
+        return await coworkManager.pauseSession(sessionId);
+    });
+    electron_1.ipcMain.handle('cowork:stop', async (event, sessionId) => {
+        return await coworkManager.stopSession(sessionId);
+    });
+    electron_1.ipcMain.handle('cowork:list', async () => {
+        return coworkManager.getSessions();
+    });
+    // Pair programming operations
+    electron_1.ipcMain.handle('pair:start', async (event, projectPath, mode, userId) => {
+        const validModes = ['collaborative', 'teacher', 'reviewer'];
+        const validMode = validModes.includes(mode) ? mode : 'collaborative';
+        return await aiPairProgramming.startSession(projectPath, validMode, userId);
+    });
+    electron_1.ipcMain.handle('pair:chat', async (event, sessionId, message) => {
+        return await aiPairProgramming.chat(sessionId, message);
+    });
+    electron_1.ipcMain.handle('pair:end', async (event, sessionId) => {
+        return await aiPairProgramming.endSession(sessionId);
+    });
+    // Smart code assistant
+    electron_1.ipcMain.handle('assistant:inlineCompletion', async (event, filePath, content, position) => {
+        return await smartCodeAssistant.provideInlineCompletion(filePath, content, position);
+    });
+    electron_1.ipcMain.handle('assistant:suggestFixes', async (event, filePath, content) => {
+        return await smartCodeAssistant.suggestFixes(filePath, content);
+    });
+    electron_1.ipcMain.handle('assistant:explain', async (event, code) => {
+        return await smartCodeAssistant.explainCode(code, 'detailed');
+    });
+    // Metrics
+    electron_1.ipcMain.handle('metrics:get', () => {
+        return MetricsCollector_1.metrics.getStats();
+    });
+    electron_1.ipcMain.handle('metrics:export', () => {
+        return MetricsCollector_1.metrics.exportMetrics();
+    });
+    electron_log_1.default.info('IPC handlers setup completed');
+}
+//# sourceMappingURL=main.js.map