projax 3.3.51 → 3.3.52

package/dist/electron/main.js

@@ -15,31 +15,75 @@ var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (
 }) : function(o, v) {
     o["default"] = v;
 });
-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;
-};
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
 Object.defineProperty(exports, "__esModule", { value: true });
 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 url_1 = require("url");
+// #region agent log
+fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:7', message: 'Importing core modules', data: { __dirname }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'F' }) }).catch(() => { });
+// #endregion
 const core_1 = require("./core");
+// #region agent log
+fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:16', message: 'Core modules imported successfully', data: {}, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'F' }) }).catch(() => { });
 let mainWindow = null;
 let apiProcess = null;
 const logWatchers = new Map();
+function resolveCliDistModulePath(moduleFileName) {
+    const candidates = [
+        // When running from CLI bundle: dist/electron/main.js -> dist/...
+        path.join(__dirname, '..', moduleFileName),
+        path.join(__dirname, '..', 'packages', 'cli', 'src', moduleFileName),
+        // When running desktop in dev: packages/desktop/dist/main.js -> packages/cli/dist/...
+        path.join(__dirname, '..', '..', 'cli', 'dist', moduleFileName),
+        path.join(__dirname, '..', '..', 'cli', 'dist', 'packages', 'cli', 'src', moduleFileName),
+    ];
+    for (const candidate of candidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    throw new Error(`Module not found: ${moduleFileName}. Tried:\n` +
+        candidates.map(p => `- ${p}`).join('\n'));
+}
+async function importCliDistModule(modulePath) {
+    // Use a file:// URL to avoid platform/path edge-cases in Node's ESM loader.
+    return await Promise.resolve(`${(0, url_1.pathToFileURL)(modulePath).href}`).then(s => __importStar(require(s)));
+}
+// #region agent log
+fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:23', message: 'Checking single instance lock', data: {}, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'E' }) }).catch(() => { });
+// #endregion
 // Prevent multiple instances
 const gotTheLock = electron_1.app.requestSingleInstanceLock();
 if (!gotTheLock) {
+    // #region agent log
+    fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:27', message: 'Single instance lock failed - another instance running', data: {}, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'E' }) }).catch(() => { });
+    // #endregion
     electron_1.app.quit();
 }
 else {
+    // #region agent log
+    fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:30', message: 'Single instance lock acquired', data: {}, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'E' }) }).catch(() => { });
+    // #endregion
     electron_1.app.on('second-instance', () => {
         // Someone tried to run a second instance, focus our window instead
         if (mainWindow) {
@@ -49,18 +93,26 @@ else {
         }
     });
     function createWindow() {
+        // #region agent log
+        fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:36', message: 'createWindow called', data: { hasMainWindow: !!mainWindow }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'B' }) }).catch(() => { });
+        // #endregion
         // Don't create a new window if one already exists
         if (mainWindow) {
+            // #region agent log
+            fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:39', message: 'Window already exists, focusing', data: {}, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'B' }) }).catch(() => { });
+            // #endregion
             mainWindow.focus();
             return;
         }
         const isDev = process.env.NODE_ENV === 'development';
+        // #region agent log
+        fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:45', message: 'Creating BrowserWindow', data: { isDev, __dirname }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'B' }) }).catch(() => { });
+        // #endregion
         mainWindow = new electron_1.BrowserWindow({
             width: 1200,
             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'),
@@ -72,23 +124,41 @@ else {
         });
         // Show window when ready to prevent white screen flash
         mainWindow.once('ready-to-show', () => {
+            // #region agent log
+            fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:63', message: 'Window ready-to-show event fired', data: {}, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'B' }) }).catch(() => { });
+            // #endregion
             mainWindow?.show();
         });
         // Load the app
         if (isDev) {
+            // #region agent log
+            fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:67', message: 'Dev mode: checking Vite server', data: { port: 7898 }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'C' }) }).catch(() => { });
+            // #endregion
             // Wait for Vite dev server to be ready before loading
             const checkServerAndLoad = (retries = 10) => {
+                // #region agent log
+                fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:70', message: 'Checking Vite server availability', data: { retries }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'C' }) }).catch(() => { });
+                // #endregion
                 const req = http.get('http://localhost:7898', (res) => {
+                    // #region agent log
+                    fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:72', message: 'Vite server is ready', data: { statusCode: res.statusCode }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'C' }) }).catch(() => { });
+                    // #endregion
                     console.log('Vite dev server is ready!');
                     mainWindow?.loadURL('http://localhost:7898');
                     mainWindow?.webContents.openDevTools();
                 });
                 req.on('error', (error) => {
+                    // #region agent log
+                    fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:76', message: 'Vite server check error', data: { error: error.message, retries }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'C' }) }).catch(() => { });
+                    // #endregion
                     if (retries > 0) {
                         console.log(`Vite dev server not ready (${retries} retries left), retrying in 1 second...`);
                         setTimeout(() => checkServerAndLoad(retries - 1), 1000);
                     }
                     else {
+                        // #region agent log
+                        fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:82', message: 'Vite server connection failed after all retries', data: { error: error.message }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'C' }) }).catch(() => { });
+                        // #endregion
                         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
@@ -126,6 +196,13 @@ else {
                 electron_1.app.quit();
             }
         }
+        // Prevent navigation on file drops (prevents default file:// protocol navigation)
+        mainWindow.webContents.on('will-navigate', (event, url) => {
+            // Allow navigation only to localhost (dev server) or file:// (local renderer)
+            if (!url.startsWith('http://localhost') && !url.startsWith('file://')) {
+                event.preventDefault();
+            }
+        });
         // Handle external links securely
         mainWindow.webContents.setWindowOpenHandler(({ url }) => {
             // Only allow http/https links to be opened externally for security
@@ -187,6 +264,9 @@ else {
     }
     // Start API server
     function startAPIServer() {
+        // #region agent log
+        fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:187', message: 'startAPIServer called', data: { __dirname, processCwd: process.cwd() }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'D' }) }).catch(() => { });
+        // #endregion
         try {
             // Try to find API server in various locations
             const apiPaths = [
@@ -194,14 +274,24 @@ else {
                 path.join(__dirname, '..', '..', 'api', 'dist', 'index.js'),
                 path.join(process.cwd(), 'packages', 'api', 'dist', 'index.js'),
             ];
+            // #region agent log
+            fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:196', message: 'Checking API paths', data: { apiPaths, __dirname }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'D' }) }).catch(() => { });
+            // #endregion
             let apiPath = null;
             for (const p of apiPaths) {
-                if (fs.existsSync(p)) {
+                const exists = fs.existsSync(p);
+                // #region agent log
+                fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:199', message: 'Checking API path', data: { path: p, exists }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'D' }) }).catch(() => { });
+                // #endregion
+                if (exists) {
                     apiPath = p;
                     break;
                 }
             }
             if (!apiPath) {
+                // #region agent log
+                fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:205', message: 'API server not found', data: { checkedPaths: apiPaths }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'D' }) }).catch(() => { });
+                // #endregion
                 console.warn('API server not found. Some features may not work.');
                 return;
             }
@@ -212,12 +302,18 @@ else {
                 apiProcess.kill();
                 apiProcess = null;
             }
+            // #region agent log
+            fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:216', message: 'Spawning API server process', data: { apiPath, cwd: path.dirname(apiPath) }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'D' }) }).catch(() => { });
+            // #endregion
             apiProcess = (0, child_process_1.spawn)('node', [apiPath], {
                 detached: false,
                 stdio: 'pipe',
                 env: { ...process.env },
                 cwd: path.dirname(apiPath),
             });
+            // #region agent log
+            fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:222', message: 'API server process spawned', data: { pid: apiProcess.pid }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'D' }) }).catch(() => { });
+            // #endregion
             apiProcess.stdout?.on('data', (data) => {
                 console.log(`[API] ${data.toString().trim()}`);
             });
@@ -237,125 +333,18 @@ else {
             });
         }
         catch (error) {
+            // #region agent log
+            fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:243', message: 'API server startup error', data: { error: error instanceof Error ? error.message : String(error) }, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'D' }) }).catch(() => { });
+            // #endregion
             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);
-    }
+    // Set app name for menu bar (macOS)
+    electron_1.app.setName('PROJAX');
     electron_1.app.whenReady().then(() => {
-        createMenu();
+        // #region agent log
+        fetch('http://127.0.0.1:7242/ingest/6c072a46-f01e-4db0-a457-6218bdb7cec6', { method: 'POST', headers: { 'Content-Type': 'application/json' }, body: JSON.stringify({ location: 'main.ts:247', message: 'App whenReady fired', data: {}, timestamp: Date.now(), sessionId: 'debug-session', runId: 'run1', hypothesisId: 'A' }) }).catch(() => { });
+        // #endregion
         startAPIServer();
         createWindow();
         electron_1.app.on('activate', () => {
@@ -395,42 +384,9 @@ electron_1.ipcMain.handle('get-app-version', async () => {
 electron_1.ipcMain.handle('get-projects', async () => {
     try {
         console.log('Getting projects from database...');
-        // 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');
+        const projects = (0, core_1.getAllProjects)();
+        console.log(`Found ${projects.length} project(s)`);
+        return projects;
     }
     catch (error) {
         console.error('Error getting projects:', error);
@@ -525,82 +481,10 @@ 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, 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');
-    const localScriptRunnerPath = path.join(__dirname, '..', '..', 'cli', 'dist', 'script-runner.js');
-    let scriptRunnerPath;
-    if (fs.existsSync(bundledScriptRunnerPath)) {
-        scriptRunnerPath = bundledScriptRunnerPath;
-    }
-    else {
-        scriptRunnerPath = localScriptRunnerPath;
-    }
-    const { getProjectScripts } = await Promise.resolve(`${scriptRunnerPath}`).then(s => __importStar(require(s)));
-    // 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);
+electron_1.ipcMain.handle('get-project-scripts', async (_, projectPath) => {
+    const scriptRunnerPath = resolveCliDistModulePath('script-runner.js');
+    const { getProjectScripts } = await importCliDistModule(scriptRunnerPath);
+    const result = getProjectScripts(projectPath);
     // Convert Map to array for IPC serialization
     const scriptsArray = Array.from(result.scripts.entries()).map(([name, script]) => ({
         name,
@@ -614,21 +498,8 @@ electron_1.ipcMain.handle('get-project-scripts', async (_, projectPath, projectI
 // Run script
 electron_1.ipcMain.handle('run-script', async (_, projectPath, scriptName, args = [], background = false) => {
     try {
-        // 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');
-        const localScriptRunnerPath = path.join(__dirname, '..', '..', 'cli', 'dist', 'script-runner.js');
-        let scriptRunnerPath;
-        if (fs.existsSync(bundledScriptRunnerPath)) {
-            scriptRunnerPath = bundledScriptRunnerPath;
-        }
-        else if (fs.existsSync(localScriptRunnerPath)) {
-            scriptRunnerPath = localScriptRunnerPath;
-        }
-        else {
-            throw new Error(`Script runner not found. Tried: ${bundledScriptRunnerPath} and ${localScriptRunnerPath}`);
-        }
-        const scriptRunnerModule = await Promise.resolve(`${scriptRunnerPath}`).then(s => __importStar(require(s)));
+        const scriptRunnerPath = resolveCliDistModulePath('script-runner.js');
+        const scriptRunnerModule = await importCliDistModule(scriptRunnerPath);
         const { runScriptInBackground } = scriptRunnerModule;
         if (!runScriptInBackground || typeof runScriptInBackground !== 'function') {
             throw new Error('runScriptInBackground function not found in script runner module');
@@ -649,35 +520,15 @@ electron_1.ipcMain.handle('run-script', async (_, projectPath, scriptName, args
 });
 // Scan ports
 electron_1.ipcMain.handle('scan-project-ports', async (_, projectId) => {
-    // Try bundled path first (when bundled in CLI: dist/electron/main.js -> dist/port-scanner.js)
-    // Then try local dev path (packages/desktop/dist/main.js -> packages/cli/dist/port-scanner.js)
-    const bundledPortScannerPath = path.join(__dirname, '..', 'port-scanner.js');
-    const localPortScannerPath = path.join(__dirname, '..', '..', 'cli', 'dist', 'port-scanner.js');
-    let portScannerPath;
-    if (fs.existsSync(bundledPortScannerPath)) {
-        portScannerPath = bundledPortScannerPath;
-    }
-    else {
-        portScannerPath = localPortScannerPath;
-    }
-    const { scanProjectPorts } = await Promise.resolve(`${portScannerPath}`).then(s => __importStar(require(s)));
+    const portScannerPath = resolveCliDistModulePath('port-scanner.js');
+    const { scanProjectPorts } = await importCliDistModule(portScannerPath);
     await scanProjectPorts(projectId);
     const db = (0, core_1.getDatabaseManager)();
     return db.getProjectPorts(projectId);
 });
 electron_1.ipcMain.handle('scan-all-ports', async () => {
-    // Try bundled path first (when bundled in CLI: dist/electron/main.js -> dist/port-scanner.js)
-    // Then try local dev path (packages/desktop/dist/main.js -> packages/cli/dist/port-scanner.js)
-    const bundledPortScannerPath = path.join(__dirname, '..', 'port-scanner.js');
-    const localPortScannerPath = path.join(__dirname, '..', '..', 'cli', 'dist', 'port-scanner.js');
-    let portScannerPath;
-    if (fs.existsSync(bundledPortScannerPath)) {
-        portScannerPath = bundledPortScannerPath;
-    }
-    else {
-        portScannerPath = localPortScannerPath;
-    }
-    const { scanAllProjectPorts } = await Promise.resolve(`${portScannerPath}`).then(s => __importStar(require(s)));
+    const portScannerPath = resolveCliDistModulePath('port-scanner.js');
+    const { scanAllProjectPorts } = await importCliDistModule(portScannerPath);
     await scanAllProjectPorts();
     const db = (0, core_1.getDatabaseManager)();
     const projects = (0, core_1.getAllProjects)();
@@ -694,50 +545,20 @@ electron_1.ipcMain.handle('get-project-ports', async (_, projectId) => {
 });
 // Get running processes
 electron_1.ipcMain.handle('get-running-processes', async () => {
-    // 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');
-    const localScriptRunnerPath = path.join(__dirname, '..', '..', 'cli', 'dist', 'script-runner.js');
-    let scriptRunnerPath;
-    if (fs.existsSync(bundledScriptRunnerPath)) {
-        scriptRunnerPath = bundledScriptRunnerPath;
-    }
-    else {
-        scriptRunnerPath = localScriptRunnerPath;
-    }
-    const { getRunningProcessesClean } = await Promise.resolve(`${scriptRunnerPath}`).then(s => __importStar(require(s)));
+    const scriptRunnerPath = resolveCliDistModulePath('script-runner.js');
+    const { getRunningProcessesClean } = await importCliDistModule(scriptRunnerPath);
     return await getRunningProcessesClean();
 });
 // Stop script by PID
 electron_1.ipcMain.handle('stop-script', async (_, pid) => {
-    // 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');
-    const localScriptRunnerPath = path.join(__dirname, '..', '..', 'cli', 'dist', 'script-runner.js');
-    let scriptRunnerPath;
-    if (fs.existsSync(bundledScriptRunnerPath)) {
-        scriptRunnerPath = bundledScriptRunnerPath;
-    }
-    else {
-        scriptRunnerPath = localScriptRunnerPath;
-    }
-    const { stopScript } = await Promise.resolve(`${scriptRunnerPath}`).then(s => __importStar(require(s)));
+    const scriptRunnerPath = resolveCliDistModulePath('script-runner.js');
+    const { stopScript } = await importCliDistModule(scriptRunnerPath);
     return await stopScript(pid);
 });
 // Stop all processes for a project
 electron_1.ipcMain.handle('stop-project', async (_, projectPath) => {
-    // 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');
-    const localScriptRunnerPath = path.join(__dirname, '..', '..', 'cli', 'dist', 'script-runner.js');
-    let scriptRunnerPath;
-    if (fs.existsSync(bundledScriptRunnerPath)) {
-        scriptRunnerPath = bundledScriptRunnerPath;
-    }
-    else {
-        scriptRunnerPath = localScriptRunnerPath;
-    }
-    const { stopProjectProcesses } = await Promise.resolve(`${scriptRunnerPath}`).then(s => __importStar(require(s)));
+    const scriptRunnerPath = resolveCliDistModulePath('script-runner.js');
+    const { stopProjectProcesses } = await importCliDistModule(scriptRunnerPath);
     return await stopProjectProcesses(projectPath);
 });
 // Open URL in browser
@@ -832,7 +653,7 @@ electron_1.ipcMain.handle('open-url', async (_, url) => {
     }).unref();
 });
 // Open project in editor
-electron_1.ipcMain.handle('open-in-editor', async (_, projectPath, projectId) => {
+electron_1.ipcMain.handle('open-in-editor', async (_, projectPath) => {
     // 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');
@@ -845,41 +666,7 @@ electron_1.ipcMain.handle('open-in-editor', async (_, projectPath, projectId) =>
         settingsPath = localSettingsPath;
     }
     const { getEditorSettings } = require(settingsPath);
-    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
-        }
-    }
+    const editorSettings = getEditorSettings();
     let command;
     let args = [projectPath];
     if (editorSettings.type === 'custom' && editorSettings.customPath) {
@@ -1009,17 +796,6 @@ 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 {
@@ -1082,17 +858,8 @@ electron_1.ipcMain.on('open-external-url', (event, url) => {
 // Watch process output
 electron_1.ipcMain.handle('watch-process-output', async (_, pid) => {
     try {
-        // Try bundled path first
-        const bundledScriptRunnerPath = path.join(__dirname, '..', 'script-runner.js');
-        const localScriptRunnerPath = path.join(__dirname, '..', '..', 'cli', 'dist', 'script-runner.js');
-        let scriptRunnerPath;
-        if (fs.existsSync(bundledScriptRunnerPath)) {
-            scriptRunnerPath = bundledScriptRunnerPath;
-        }
-        else {
-            scriptRunnerPath = localScriptRunnerPath;
-        }
-        const { getRunningProcessesClean } = await Promise.resolve(`${scriptRunnerPath}`).then(s => __importStar(require(s)));
+        const scriptRunnerPath = resolveCliDistModulePath('script-runner.js');
+        const { getRunningProcessesClean } = await importCliDistModule(scriptRunnerPath);
         const processes = await getRunningProcessesClean();
         const process = processes.find((p) => p.pid === pid);
         if (!process || !process.logFile) {
@@ -1155,87 +922,19 @@ electron_1.ipcMain.handle('unwatch-process-output', async (_, pid) => {
 // 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 [];
+        const response = await fetch('http://localhost:3001/api/workspaces');
+        if (!response.ok)
+            throw new Error('Failed to fetch workspaces');
+        return await response.json();
     }
     catch (error) {
         console.error('Error getting workspaces:', error);
-        // Return empty array instead of throwing to prevent app crash
-        return [];
+        throw error;
     }
 });
 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`, {
+        const response = await fetch('http://localhost:3001/api/workspaces', {
             method: 'POST',
             headers: { 'Content-Type': 'application/json' },
             body: JSON.stringify(workspace),