projax 3.3.39 → 3.3.51

package/dist/electron/main.js

@@ -15,27 +15,19 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : 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 __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 Object.defineProperty(exports, "__esModule", { value: true });
 const electron_1 = require("electron");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
+const http = __importStar(require("http"));
 const child_process_1 = require("child_process");
 const tail_1 = require("tail");
 const core_1 = require("./core");
@@ -68,17 +60,53 @@ else {
             height: 800,
             frame: false,
             titleBarStyle: 'hidden',
+            trafficLightPosition: { x: -100, y: -100 }, // Hide macOS traffic lights
             title: 'PROJAX UI',
             webPreferences: {
                 preload: path.join(__dirname, 'preload.js'),
                 nodeIntegration: false,
                 contextIsolation: true,
+                webSecurity: true,
             },
+            show: false, // Don't show until ready
+        });
+        // Show window when ready to prevent white screen flash
+        mainWindow.once('ready-to-show', () => {
+            mainWindow?.show();
         });
         // Load the app
         if (isDev) {
-            mainWindow.loadURL('http://localhost:7898');
-            mainWindow.webContents.openDevTools();
+            // Wait for Vite dev server to be ready before loading
+            const checkServerAndLoad = (retries = 10) => {
+                const req = http.get('http://localhost:7898', (res) => {
+                    console.log('Vite dev server is ready!');
+                    mainWindow?.loadURL('http://localhost:7898');
+                    mainWindow?.webContents.openDevTools();
+                });
+                req.on('error', (error) => {
+                    if (retries > 0) {
+                        console.log(`Vite dev server not ready (${retries} retries left), retrying in 1 second...`);
+                        setTimeout(() => checkServerAndLoad(retries - 1), 1000);
+                    }
+                    else {
+                        console.error('Failed to connect to Vite dev server after multiple retries');
+                        console.error('Make sure Vite is running on port 7898');
+                        mainWindow?.loadURL('http://localhost:7898'); // Try anyway
+                    }
+                });
+                req.setTimeout(2000, () => {
+                    req.destroy();
+                    if (retries > 0) {
+                        console.log(`Vite dev server timeout (${retries} retries left), retrying...`);
+                        setTimeout(() => checkServerAndLoad(retries - 1), 1000);
+                    }
+                    else {
+                        console.error('Failed to connect to Vite dev server - timeout');
+                        mainWindow?.loadURL('http://localhost:7898'); // Try anyway
+                    }
+                });
+            };
+            checkServerAndLoad();
         }
         else {
             // Try bundled renderer path first (when bundled in CLI: dist/electron/renderer/index.html)
@@ -113,6 +141,49 @@ else {
         mainWindow.on('closed', () => {
             mainWindow = null;
         });
+        // Handle page load errors
+        mainWindow.webContents.on('did-fail-load', (event, errorCode, errorDescription, validatedURL) => {
+            console.error('Failed to load:', validatedURL, errorCode, errorDescription);
+            if (isDev && validatedURL === 'http://localhost:7898/') {
+                console.log('Retrying to load Vite dev server...');
+                setTimeout(() => {
+                    mainWindow?.loadURL('http://localhost:7898');
+                }, 2000);
+            }
+        });
+        // Log when page finishes loading
+        mainWindow.webContents.on('did-finish-load', () => {
+            console.log('Page loaded successfully');
+        });
+        // Log console messages from renderer
+        mainWindow.webContents.on('console-message', (event, level, message, line, sourceId) => {
+            console.log(`[Renderer ${level}]:`, message, sourceId ? `(${sourceId}:${line})` : '');
+        });
+        // Log all console output from renderer
+        mainWindow.webContents.on('did-fail-load', (event, errorCode, errorDescription, validatedURL, isMainFrame) => {
+            if (isMainFrame) {
+                console.error('Main frame failed to load:', {
+                    errorCode,
+                    errorDescription,
+                    validatedURL,
+                });
+            }
+        });
+        // Add keyboard shortcut to reload in dev mode
+        if (isDev) {
+            mainWindow.webContents.on('before-input-event', (event, input) => {
+                // Cmd+R or Ctrl+R to reload
+                if ((input.control || input.meta) && input.key.toLowerCase() === 'r') {
+                    event.preventDefault();
+                    mainWindow?.reload();
+                }
+                // Cmd+Shift+R or Ctrl+Shift+R to hard reload
+                if ((input.control || input.meta) && input.shift && input.key.toLowerCase() === 'r') {
+                    event.preventDefault();
+                    mainWindow?.webContents.reloadIgnoringCache();
+                }
+            });
+        }
     }
     // Start API server
     function startAPIServer() {
@@ -134,11 +205,18 @@ else {
                 console.warn('API server not found. Some features may not work.');
                 return;
             }
-            console.log('Starting API server...');
+            console.log('Starting API server from:', apiPath);
+            // Kill any existing API server on the same port first
+            if (apiProcess) {
+                console.log('Killing existing API server...');
+                apiProcess.kill();
+                apiProcess = null;
+            }
             apiProcess = (0, child_process_1.spawn)('node', [apiPath], {
                 detached: false,
                 stdio: 'pipe',
                 env: { ...process.env },
+                cwd: path.dirname(apiPath),
             });
             apiProcess.stdout?.on('data', (data) => {
                 console.log(`[API] ${data.toString().trim()}`);
@@ -149,13 +227,135 @@ else {
             apiProcess.on('exit', (code) => {
                 console.log(`API server exited with code ${code}`);
                 apiProcess = null;
+                // Restart API server if it crashes (wait 2 seconds)
+                if (code !== 0) {
+                    console.log('API server crashed, restarting in 2 seconds...');
+                    setTimeout(() => {
+                        startAPIServer();
+                    }, 2000);
+                }
             });
         }
         catch (error) {
             console.error('Failed to start API server:', error);
         }
     }
+    function createMenu() {
+        const template = [
+            {
+                label: 'PROJAX UI',
+                submenu: [
+                    { role: 'about', label: 'About PROJAX UI' },
+                    { type: 'separator' },
+                    { role: 'services', label: 'Services' },
+                    { type: 'separator' },
+                    { role: 'hide', label: 'Hide PROJAX UI' },
+                    { role: 'hideOthers', label: 'Hide Others' },
+                    { role: 'unhide', label: 'Show All' },
+                    { type: 'separator' },
+                    { role: 'quit', label: 'Quit PROJAX UI' },
+                ],
+            },
+            {
+                label: 'File',
+                submenu: [
+                    {
+                        label: 'New Project',
+                        accelerator: 'CmdOrCtrl+N',
+                        click: () => {
+                            if (mainWindow) {
+                                mainWindow.webContents.send('menu-action', 'new-project');
+                            }
+                        },
+                    },
+                    {
+                        label: 'New Workspace',
+                        accelerator: 'CmdOrCtrl+Shift+N',
+                        click: () => {
+                            if (mainWindow) {
+                                mainWindow.webContents.send('menu-action', 'new-workspace');
+                            }
+                        },
+                    },
+                    { type: 'separator' },
+                    {
+                        label: 'Open Workspace',
+                        accelerator: 'CmdOrCtrl+O',
+                        click: () => {
+                            if (mainWindow) {
+                                mainWindow.webContents.send('menu-action', 'open-workspace');
+                            }
+                        },
+                    },
+                    {
+                        label: 'Open Directory as New Project',
+                        accelerator: 'CmdOrCtrl+Shift+O',
+                        click: async () => {
+                            if (mainWindow) {
+                                const result = await electron_1.dialog.showOpenDialog(mainWindow, {
+                                    properties: ['openDirectory'],
+                                });
+                                if (!result.canceled && result.filePaths.length > 0) {
+                                    mainWindow.webContents.send('menu-action', 'open-directory-as-project', result.filePaths[0]);
+                                }
+                            }
+                        },
+                    },
+                    { type: 'separator' },
+                    { role: 'close', label: 'Close Window' },
+                ],
+            },
+            {
+                label: 'Edit',
+                submenu: [
+                    { role: 'undo', label: 'Undo' },
+                    { role: 'redo', label: 'Redo' },
+                    { type: 'separator' },
+                    { role: 'cut', label: 'Cut' },
+                    { role: 'copy', label: 'Copy' },
+                    { role: 'paste', label: 'Paste' },
+                    { role: 'selectAll', label: 'Select All' },
+                ],
+            },
+            {
+                label: 'View',
+                submenu: [
+                    { role: 'reload', label: 'Reload' },
+                    { role: 'forceReload', label: 'Force Reload' },
+                    { role: 'toggleDevTools', label: 'Toggle Developer Tools' },
+                    { type: 'separator' },
+                    { role: 'resetZoom', label: 'Actual Size' },
+                    { role: 'zoomIn', label: 'Zoom In' },
+                    { role: 'zoomOut', label: 'Zoom Out' },
+                    { type: 'separator' },
+                    { role: 'togglefullscreen', label: 'Toggle Full Screen' },
+                ],
+            },
+            {
+                label: 'Window',
+                submenu: [
+                    { role: 'minimize', label: 'Minimize' },
+                    { role: 'close', label: 'Close' },
+                ],
+            },
+        ];
+        // macOS specific menu adjustments
+        if (process.platform === 'darwin') {
+            template[0].label = 'PROJAX UI';
+        }
+        else {
+            // Windows/Linux: Remove the app menu and move items to File menu
+            template.shift();
+            const fileMenu = template[0];
+            if (fileMenu.submenu && Array.isArray(fileMenu.submenu)) {
+                fileMenu.submenu.push({ type: 'separator' }, { role: 'quit', label: 'Exit' });
+            }
+        }
+        const menu = electron_1.Menu.buildFromTemplate(template);
+        electron_1.Menu.setApplicationMenu(menu);
+    }
     electron_1.app.whenReady().then(() => {
+        createMenu();
         startAPIServer();
         createWindow();
         electron_1.app.on('activate', () => {
@@ -195,9 +395,42 @@ electron_1.ipcMain.handle('get-app-version', async () => {
 electron_1.ipcMain.handle('get-projects', async () => {
     try {
         console.log('Getting projects from database...');
-        const projects = (0, core_1.getAllProjects)();
-        console.log(`Found ${projects.length} project(s)`);
-        return projects;
+        // Wait a bit for API server to be ready if it just started
+        // Try to get projects, with a retry if it fails
+        let projects = [];
+        let lastError = null;
+        for (let attempt = 0; attempt < 3; attempt++) {
+            try {
+                projects = (0, core_1.getAllProjects)();
+                console.log(`Found ${projects.length} project(s)`);
+                return projects;
+            }
+            catch (error) {
+                lastError = error instanceof Error ? error : new Error(String(error));
+                if (attempt < 2) {
+                    // Wait a bit before retrying (API server might be starting)
+                    await new Promise(resolve => setTimeout(resolve, 500));
+                }
+            }
+        }
+        // If all retries failed, try reading directly from database file as fallback
+        try {
+            const dataDir = path.join(os.homedir(), '.projax');
+            const dbPath = path.join(dataDir, 'data.json');
+            if (fs.existsSync(dbPath)) {
+                const dbContent = fs.readFileSync(dbPath, 'utf-8');
+                const db = JSON.parse(dbContent);
+                if (db.projects && Array.isArray(db.projects)) {
+                    console.log(`Fallback: Found ${db.projects.length} project(s) from database file`);
+                    return db.projects;
+                }
+            }
+        }
+        catch (fileError) {
+            console.warn('Could not read projects from database file:', fileError);
+        }
+        // If we still don't have projects, throw the original error
+        throw lastError || new Error('Failed to get projects');
     }
     catch (error) {
         console.error('Error getting projects:', error);
@@ -292,7 +525,7 @@ electron_1.ipcMain.handle('rename-project', async (_, projectId, newName) => {
     return db.updateProjectName(projectId, newName);
 });
 // Get project scripts
-electron_1.ipcMain.handle('get-project-scripts', async (_, projectPath) => {
+electron_1.ipcMain.handle('get-project-scripts', async (_, projectPath, projectId) => {
     // Try bundled path first (when bundled in CLI: dist/electron/main.js -> dist/script-runner.js)
     // Then try local dev path (packages/desktop/dist/main.js -> packages/cli/dist/script-runner.js)
     const bundledScriptRunnerPath = path.join(__dirname, '..', 'script-runner.js');
@@ -305,7 +538,69 @@ electron_1.ipcMain.handle('get-project-scripts', async (_, projectPath) => {
         scriptRunnerPath = localScriptRunnerPath;
     }
     const { getProjectScripts } = await Promise.resolve(`${scriptRunnerPath}`).then(s => __importStar(require(s)));
-    const result = getProjectScripts(projectPath);
+    // Get project settings if projectId is provided
+    // Read directly from database file instead of making HTTP requests
+    let scriptsPath = null;
+    if (projectId) {
+        try {
+            const dataDir = path.join(os.homedir(), '.projax');
+            const dbPath = path.join(dataDir, 'data.json');
+            // Try reading the file with a small retry in case it's being written
+            let db = null;
+            for (let attempt = 0; attempt < 3; attempt++) {
+                try {
+                    if (fs.existsSync(dbPath)) {
+                        const dbContent = fs.readFileSync(dbPath, 'utf-8');
+                        db = JSON.parse(dbContent);
+                        break; // Successfully read, exit retry loop
+                    }
+                }
+                catch (readError) {
+                    if (attempt < 2) {
+                        // Wait a bit before retrying (only on first two attempts)
+                        await new Promise(resolve => setTimeout(resolve, 100));
+                        continue;
+                    }
+                    throw readError;
+                }
+            }
+            if (db && db.project_settings && Array.isArray(db.project_settings)) {
+                const settings = db.project_settings.find((ps) => ps.project_id === projectId);
+                if (settings && settings.scripts_path) {
+                    scriptsPath = settings.scripts_path;
+                }
+            }
+        }
+        catch (error) {
+            // Silently fail - will use project root if settings can't be loaded
+            console.debug('Could not load project settings for scripts, using project root:', error);
+        }
+    }
+    // Use custom scripts path if set, otherwise use project root
+    let actualScriptsPath = projectPath;
+    if (scriptsPath) {
+        const joinedPath = path.join(projectPath, scriptsPath);
+        // Validate that the path exists
+        if (fs.existsSync(joinedPath)) {
+            const stats = fs.statSync(joinedPath);
+            if (stats.isDirectory()) {
+                // If it's a directory, use it directly
+                actualScriptsPath = joinedPath;
+            }
+            else if (stats.isFile()) {
+                // If it's a file, use the directory containing the file
+                actualScriptsPath = path.dirname(joinedPath);
+            }
+            else {
+                console.warn(`Custom scripts path is not a directory or file: ${joinedPath}, using project root instead`);
+            }
+        }
+        else {
+            console.warn(`Custom scripts path does not exist: ${joinedPath}, using project root instead`);
+            // Fall back to project root if custom path doesn't exist
+        }
+    }
+    const result = getProjectScripts(actualScriptsPath);
     // Convert Map to array for IPC serialization
     const scriptsArray = Array.from(result.scripts.entries()).map(([name, script]) => ({
         name,
@@ -537,11 +832,11 @@ electron_1.ipcMain.handle('open-url', async (_, url) => {
     }).unref();
 });
 // Open project in editor
-electron_1.ipcMain.handle('open-in-editor', async (_, projectPath) => {
+electron_1.ipcMain.handle('open-in-editor', async (_, projectPath, projectId) => {
     // Try bundled path first (when bundled in CLI: dist/electron/main.js -> dist/core/settings)
     // Then try local dev path (packages/desktop/dist/main.js -> packages/core/dist/settings)
-    const bundledSettingsPath = path.join(__dirname, '..', 'core', 'settings');
-    const localSettingsPath = path.join(__dirname, '..', '..', '..', 'core', 'dist', 'settings');
+    const bundledSettingsPath = path.join(__dirname, 'core', 'settings');
+    const localSettingsPath = path.join(__dirname, '..', '..', 'core', 'dist', 'settings');
     let settingsPath;
     if (fs.existsSync(bundledSettingsPath + '.js')) {
         settingsPath = bundledSettingsPath;
@@ -550,7 +845,41 @@ electron_1.ipcMain.handle('open-in-editor', async (_, projectPath) => {
         settingsPath = localSettingsPath;
     }
     const { getEditorSettings } = require(settingsPath);
-    const editorSettings = getEditorSettings();
+    const globalEditorSettings = getEditorSettings();
+    // Check for project-specific editor settings
+    let editorSettings = globalEditorSettings;
+    if (projectId) {
+        try {
+            const ports = [38124, 38125, 38126, 38127, 38128, 3001];
+            let apiBaseUrl = '';
+            for (const port of ports) {
+                try {
+                    const response = await fetch(`http://localhost:${port}/health`, { signal: AbortSignal.timeout(500) });
+                    if (response.ok) {
+                        apiBaseUrl = `http://localhost:${port}/api`;
+                        break;
+                    }
+                }
+                catch {
+                    continue;
+                }
+            }
+            if (apiBaseUrl) {
+                const settingsResponse = await fetch(`${apiBaseUrl}/projects/${projectId}/settings`);
+                if (settingsResponse.ok) {
+                    const projectSettings = await settingsResponse.json();
+                    if (projectSettings.editor && projectSettings.editor.type) {
+                        // Use project-specific editor
+                        editorSettings = projectSettings.editor;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            console.error('Error loading project editor settings:', error);
+            // Fall back to global settings
+        }
+    }
     let command;
     let args = [projectPath];
     if (editorSettings.type === 'custom' && editorSettings.customPath) {
@@ -580,6 +909,96 @@ electron_1.ipcMain.handle('open-in-editor', async (_, projectPath) => {
         stdio: 'ignore',
     }).unref();
 });
+// Open workspace in editor
+electron_1.ipcMain.handle('open-workspace', async (_, workspaceId) => {
+    try {
+        // Get workspace file path from API (ensures file exists)
+        const ports = [38124, 38125, 38126, 38127, 38128, 3001];
+        let apiBaseUrl = '';
+        for (const port of ports) {
+            try {
+                const response = await fetch(`http://localhost:${port}/health`, { signal: AbortSignal.timeout(500) });
+                if (response.ok) {
+                    apiBaseUrl = `http://localhost:${port}/api`;
+                    break;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        if (!apiBaseUrl) {
+            throw new Error('API server not found');
+        }
+        // Get workspace file path (this will generate it if needed)
+        const response = await fetch(`${apiBaseUrl}/workspaces/${workspaceId}/file-path`);
+        if (!response.ok) {
+            throw new Error('Failed to get workspace file path');
+        }
+        const data = await response.json();
+        const workspace_file_path = data.workspace_file_path;
+        if (!fs.existsSync(workspace_file_path)) {
+            throw new Error('Workspace file does not exist');
+        }
+        // Open workspace file in editor (workspace files are opened with the workspace flag)
+        const bundledSettingsPath = path.join(__dirname, 'core', 'settings');
+        const localSettingsPath = path.join(__dirname, '..', '..', 'core', 'dist', 'settings');
+        let settingsPath;
+        if (fs.existsSync(bundledSettingsPath + '.js')) {
+            settingsPath = bundledSettingsPath;
+        }
+        else {
+            settingsPath = localSettingsPath;
+        }
+        const { getEditorSettings } = require(settingsPath);
+        const editorSettings = getEditorSettings();
+        let command;
+        let args = [];
+        if (editorSettings.type === 'custom' && editorSettings.customPath) {
+            command = editorSettings.customPath;
+            // For custom editors, try workspace file as argument
+            args = [workspace_file_path];
+        }
+        else {
+            switch (editorSettings.type) {
+                case 'vscode':
+                case 'cursor':
+                case 'windsurf':
+                    // VS Code, Cursor, and Windsurf support opening workspace files directly
+                    command = editorSettings.type === 'vscode' ? 'code' : editorSettings.type === 'cursor' ? 'cursor' : 'windsurf';
+                    args = [workspace_file_path];
+                    break;
+                case 'zed':
+                    // Zed doesn't support workspace files, open the first project folder instead
+                    const workspaceContent = JSON.parse(fs.readFileSync(workspace_file_path, 'utf-8'));
+                    if (workspaceContent.folders && workspaceContent.folders.length > 0) {
+                        const firstFolder = workspaceContent.folders[0];
+                        const folderPath = path.isAbsolute(firstFolder.path)
+                            ? firstFolder.path
+                            : path.resolve(path.dirname(workspace_file_path), firstFolder.path);
+                        command = 'zed';
+                        args = [folderPath];
+                    }
+                    else {
+                        throw new Error('Workspace has no folders to open');
+                    }
+                    break;
+                default:
+                    command = 'code';
+                    args = [workspace_file_path];
+            }
+        }
+        const { spawn } = require('child_process');
+        spawn(command, args, {
+            detached: true,
+            stdio: 'ignore',
+        }).unref();
+    }
+    catch (error) {
+        console.error('Error opening workspace:', error);
+        throw error;
+    }
+});
 // Open project directory in file manager
 electron_1.ipcMain.handle('open-in-files', async (_, projectPath) => {
     try {
@@ -590,12 +1009,23 @@ electron_1.ipcMain.handle('open-in-files', async (_, projectPath) => {
         throw error;
     }
 });
+// Open file path in file manager (reveals file in finder/explorer)
+electron_1.ipcMain.handle('open-file-path', async (_, filePath) => {
+    try {
+        // Use shell.showItemInFolder to reveal the file in the file manager
+        electron_1.shell.showItemInFolder(filePath);
+    }
+    catch (error) {
+        console.error('Error opening file path:', error);
+        throw error;
+    }
+});
 // Get settings
 electron_1.ipcMain.handle('get-settings', async () => {
     try {
         // Load settings module directly
-        const bundledSettingsPath = path.join(__dirname, '..', 'core', 'settings');
-        const localSettingsPath = path.join(__dirname, '..', '..', '..', 'core', 'dist', 'settings');
+        const bundledSettingsPath = path.join(__dirname, 'core', 'settings');
+        const localSettingsPath = path.join(__dirname, '..', '..', 'core', 'dist', 'settings');
         let settingsPath;
         if (fs.existsSync(bundledSettingsPath + '.js')) {
             settingsPath = bundledSettingsPath;
@@ -615,8 +1045,8 @@ electron_1.ipcMain.handle('get-settings', async () => {
 electron_1.ipcMain.handle('save-settings', async (_, settings) => {
     try {
         // Load settings module directly
-        const bundledSettingsPath = path.join(__dirname, '..', 'core', 'settings');
-        const localSettingsPath = path.join(__dirname, '..', '..', '..', 'core', 'dist', 'settings');
+        const bundledSettingsPath = path.join(__dirname, 'core', 'settings');
+        const localSettingsPath = path.join(__dirname, '..', '..', 'core', 'dist', 'settings');
         let settingsPath;
         if (fs.existsSync(bundledSettingsPath + '.js')) {
             settingsPath = bundledSettingsPath;
@@ -722,3 +1152,203 @@ electron_1.ipcMain.handle('unwatch-process-output', async (_, pid) => {
     }
     return { success: false };
 });
+// Workspace handlers
+electron_1.ipcMain.handle('get-workspaces', async () => {
+    try {
+        // Try to find the correct API port
+        const ports = [38124, 38125, 38126, 38127, 38128, 3001];
+        let apiBaseUrl = '';
+        for (const port of ports) {
+            try {
+                const response = await fetch(`http://localhost:${port}/health`, { signal: AbortSignal.timeout(500) });
+                if (response.ok) {
+                    apiBaseUrl = `http://localhost:${port}/api`;
+                    break;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        // Try fetching from API with retries
+        if (apiBaseUrl) {
+            for (let i = 0; i < 3; i++) {
+                try {
+                    const response = await fetch(`${apiBaseUrl}/workspaces`);
+                    if (response.ok) {
+                        const workspaces = await response.json();
+                        console.log(`[main] Fetched ${workspaces.length} workspace(s) from API.`);
+                        return workspaces;
+                    }
+                }
+                catch (error) {
+                    console.debug(`[main] API fetch attempt ${i + 1} failed:`, error);
+                    if (i < 2) {
+                        await new Promise(resolve => setTimeout(resolve, 500)); // Wait 500ms before retry
+                    }
+                }
+            }
+        }
+        // Fallback to reading directly from database file if API is not available or failed
+        try {
+            console.warn('[main] API not available or failed after retries. Reading workspaces directly from database file.');
+            const dataDir = path.join(os.homedir(), '.projax');
+            const dbPath = path.join(dataDir, 'data.json');
+            if (fs.existsSync(dbPath)) {
+                const dbContent = fs.readFileSync(dbPath, 'utf-8');
+                const db = JSON.parse(dbContent);
+                const workspaces = db.workspaces || [];
+                console.log(`[main] Found ${workspaces.length} workspace(s) in database file.`);
+                return workspaces;
+            }
+        }
+        catch (fileError) {
+            console.warn('[main] Could not read workspaces from database file:', fileError);
+        }
+        // If we still don't have workspaces, return empty array
+        console.warn('[main] No workspaces found, returning empty array.');
+        return [];
+    }
+    catch (error) {
+        console.error('Error getting workspaces:', error);
+        // Return empty array instead of throwing to prevent app crash
+        return [];
+    }
+});
+electron_1.ipcMain.handle('add-workspace', async (_, workspace) => {
+    try {
+        // Try to find the correct API port
+        const ports = [38124, 38125, 38126, 38127, 38128, 3001];
+        let apiBaseUrl = '';
+        for (const port of ports) {
+            try {
+                const response = await fetch(`http://localhost:${port}/health`, { signal: AbortSignal.timeout(500) });
+                if (response.ok) {
+                    apiBaseUrl = `http://localhost:${port}/api`;
+                    break;
+                }
+            }
+            catch {
+                continue;
+            }
+        }
+        if (!apiBaseUrl) {
+            throw new Error('API server not found');
+        }
+        const response = await fetch(`${apiBaseUrl}/workspaces`, {
+            method: 'POST',
+            headers: { 'Content-Type': 'application/json' },
+            body: JSON.stringify(workspace),
+        });
+        if (!response.ok) {
+            const errorData = await response.json();
+            throw new Error(errorData.error || 'Failed to add workspace');
+        }
+        return await response.json();
+    }
+    catch (error) {
+        console.error('Error adding workspace:', error);
+        throw error;
+    }
+});
+electron_1.ipcMain.handle('remove-workspace', async (_, workspaceId) => {
+    try {
+        const response = await fetch(`http://localhost:3001/api/workspaces/${workspaceId}`, {
+            method: 'DELETE',
+        });
+        if (!response.ok)
+            throw new Error('Failed to remove workspace');
+    }
+    catch (error) {
+        console.error('Error removing workspace:', error);
+        throw error;
+    }
+});
+// Backup handlers
+electron_1.ipcMain.handle('create-backup', async (_, outputPath) => {
+    try {
+        // Try to load from dist first, then src
+        const backupUtilsPath = path.join(__dirname, '..', '..', 'core', 'dist', 'backup-utils.js');
+        const backupUtilsSrcPath = path.join(__dirname, '..', '..', 'core', 'src', 'backup-utils.ts');
+        let backupUtils;
+        if (fs.existsSync(backupUtilsPath)) {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            backupUtils = require(backupUtilsPath);
+        }
+        else if (fs.existsSync(backupUtilsSrcPath.replace('.ts', '.js'))) {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            backupUtils = require(backupUtilsSrcPath.replace('.ts', '.js'));
+        }
+        else {
+            throw new Error('Backup utils not found');
+        }
+        const { createBackup } = backupUtils;
+        const backupPath = await createBackup(outputPath);
+        return { success: true, backup_path: backupPath };
+    }
+    catch (error) {
+        console.error('Error creating backup:', error);
+        throw error;
+    }
+});
+electron_1.ipcMain.handle('restore-backup', async (_, backupPath) => {
+    try {
+        // Try to load from dist first, then src
+        const backupUtilsPath = path.join(__dirname, '..', '..', 'core', 'dist', 'backup-utils.js');
+        const backupUtilsSrcPath = path.join(__dirname, '..', '..', 'core', 'src', 'backup-utils.ts');
+        let backupUtils;
+        if (fs.existsSync(backupUtilsPath)) {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            backupUtils = require(backupUtilsPath);
+        }
+        else if (fs.existsSync(backupUtilsSrcPath.replace('.ts', '.js'))) {
+            // eslint-disable-next-line @typescript-eslint/no-var-requires
+            backupUtils = require(backupUtilsSrcPath.replace('.ts', '.js'));
+        }
+        else {
+            throw new Error('Backup utils not found');
+        }
+        const { restoreBackup } = backupUtils;
+        await restoreBackup(backupPath);
+        return { success: true };
+    }
+    catch (error) {
+        console.error('Error restoring backup:', error);
+        throw error;
+    }
+});
+// File dialog handlers
+electron_1.ipcMain.handle('show-save-dialog', async (_, options) => {
+    if (!mainWindow)
+        return { canceled: true };
+    const result = await electron_1.dialog.showSaveDialog(mainWindow, {
+        title: options.title || 'Save File',
+        defaultPath: options.defaultPath,
+        filters: options.filters || [{ name: 'All Files', extensions: ['*'] }],
+    });
+    return result;
+});
+electron_1.ipcMain.handle('show-open-dialog', async (_, options) => {
+    if (!mainWindow)
+        return { canceled: true };
+    const result = await electron_1.dialog.showOpenDialog(mainWindow, {
+        title: options.title || 'Open File',
+        defaultPath: options.defaultPath,
+        filters: options.filters || [{ name: 'All Files', extensions: ['*'] }],
+        properties: options.properties || ['openFile'],
+    });
+    return result;
+});
+electron_1.ipcMain.handle('select-file', async (_, options) => {
+    if (!mainWindow)
+        return null;
+    const result = await electron_1.dialog.showOpenDialog(mainWindow, {
+        title: options.title || 'Select File',
+        defaultPath: options.defaultPath,
+        filters: options.filters || [{ name: 'All Files', extensions: ['*'] }],
+        properties: ['openFile'],
+    });
+    if (result.canceled || result.filePaths.length === 0)
+        return null;
+    return result.filePaths[0];
+});