projax 0.1.29 → 1.0.1

package/dist/electron/main.js

@@ -308,3 +308,240 @@ electron_1.ipcMain.handle('get-project-ports', async (_, projectId) => {
     const db = getDatabaseManager();
     return db.getProjectPorts(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/electron/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 { getRunningProcesses } = await Promise.resolve(`${scriptRunnerPath}`).then(s => __importStar(require(s)));
+    return getRunningProcesses();
+});
+// 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/electron/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)));
+    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/electron/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)));
+    return await stopProjectProcesses(projectPath);
+});
+// Open URL in browser
+electron_1.ipcMain.handle('open-url', async (_, url) => {
+    // Try bundled path first (when bundled in CLI: dist/electron/main.js -> dist/core)
+    // Then try local dev path (packages/electron/dist/main.js -> packages/core/dist)
+    const bundledCorePath = path.join(__dirname, '..', 'core');
+    const localCorePath = path.join(__dirname, '..', '..', '..', 'core', 'dist');
+    let corePath;
+    if (fs.existsSync(bundledCorePath)) {
+        corePath = bundledCorePath;
+    }
+    else {
+        corePath = localCorePath;
+    }
+    const { getBrowserSettings } = await Promise.resolve(`${corePath}`).then(s => __importStar(require(s)));
+    const browserSettings = getBrowserSettings();
+    let command;
+    let args = [url];
+    if (browserSettings.type === 'custom' && browserSettings.customPath) {
+        command = browserSettings.customPath;
+    }
+    else {
+        // Platform-specific browser commands
+        if (process.platform === 'darwin') {
+            // macOS
+            switch (browserSettings.type) {
+                case 'chrome':
+                    command = '/Applications/Google Chrome.app/Contents/MacOS/Google Chrome';
+                    break;
+                case 'firefox':
+                    command = '/Applications/Firefox.app/Contents/MacOS/firefox';
+                    break;
+                case 'safari':
+                    command = 'open';
+                    args = ['-a', 'Safari', url];
+                    break;
+                case 'edge':
+                    command = '/Applications/Microsoft Edge.app/Contents/MacOS/Microsoft Edge';
+                    break;
+                default:
+                    command = 'open';
+                    args = [url];
+            }
+        }
+        else if (process.platform === 'win32') {
+            // Windows
+            switch (browserSettings.type) {
+                case 'chrome':
+                    command = 'chrome';
+                    break;
+                case 'firefox':
+                    command = 'firefox';
+                    break;
+                case 'edge':
+                    command = 'msedge';
+                    break;
+                case 'safari':
+                    command = 'safari';
+                    break;
+                default:
+                    command = 'start';
+                    args = [url];
+            }
+        }
+        else {
+            // Linux
+            switch (browserSettings.type) {
+                case 'chrome':
+                    command = 'google-chrome';
+                    break;
+                case 'firefox':
+                    command = 'firefox';
+                    break;
+                case 'edge':
+                    command = 'microsoft-edge';
+                    break;
+                case 'safari':
+                    command = 'safari';
+                    break;
+                default:
+                    command = 'xdg-open';
+                    args = [url];
+            }
+        }
+    }
+    const { spawn } = require('child_process');
+    spawn(command, args, {
+        detached: true,
+        stdio: 'ignore',
+    }).unref();
+});
+// Open project in editor
+electron_1.ipcMain.handle('open-in-editor', async (_, projectPath) => {
+    // Try bundled path first (when bundled in CLI: dist/electron/main.js -> dist/core)
+    // Then try local dev path (packages/electron/dist/main.js -> packages/core/dist)
+    const bundledCorePath = path.join(__dirname, '..', 'core');
+    const localCorePath = path.join(__dirname, '..', '..', '..', 'core', 'dist');
+    let corePath;
+    if (fs.existsSync(bundledCorePath)) {
+        corePath = bundledCorePath;
+    }
+    else {
+        corePath = localCorePath;
+    }
+    const { getEditorSettings } = await Promise.resolve(`${corePath}`).then(s => __importStar(require(s)));
+    const editorSettings = getEditorSettings();
+    let command;
+    let args = [projectPath];
+    if (editorSettings.type === 'custom' && editorSettings.customPath) {
+        command = editorSettings.customPath;
+    }
+    else {
+        switch (editorSettings.type) {
+            case 'vscode':
+                command = 'code';
+                break;
+            case 'cursor':
+                command = 'cursor';
+                break;
+            case 'windsurf':
+                command = 'windsurf';
+                break;
+            case 'zed':
+                command = 'zed';
+                break;
+            default:
+                command = 'code'; // Default to VS Code
+        }
+    }
+    const { spawn } = require('child_process');
+    spawn(command, args, {
+        detached: true,
+        stdio: 'ignore',
+    }).unref();
+});
+// Get settings
+electron_1.ipcMain.handle('get-settings', async () => {
+    try {
+        // Use the same import pattern as other handlers
+        let settingsModule;
+        try {
+            // Try relative import first (when bundled in CLI: dist/electron/main.js -> dist/core)
+            settingsModule = require('../core');
+        }
+        catch {
+            try {
+                // Try alternative path (local development: packages/electron/dist/main.js -> packages/cli/dist/core)
+                settingsModule = require('../../cli/dist/core');
+            }
+            catch {
+                // Fallback to package import
+                settingsModule = require('@projax/core');
+            }
+        }
+        const { getAppSettings } = settingsModule;
+        return getAppSettings();
+    }
+    catch (error) {
+        console.error('Error getting settings:', error);
+        throw error;
+    }
+});
+// Save settings
+electron_1.ipcMain.handle('save-settings', async (_, settings) => {
+    try {
+        // Use the same import pattern as other handlers
+        let settingsModule;
+        try {
+            // Try relative import first (when bundled in CLI: dist/electron/main.js -> dist/core)
+            settingsModule = require('../core');
+        }
+        catch {
+            try {
+                // Try alternative path (local development: packages/electron/dist/main.js -> packages/cli/dist/core)
+                settingsModule = require('../../cli/dist/core');
+            }
+            catch {
+                // Fallback to package import
+                settingsModule = require('@projax/core');
+            }
+        }
+        const { setAppSettings } = settingsModule;
+        setAppSettings(settings);
+        console.log('Settings saved successfully');
+    }
+    catch (error) {
+        console.error('Error saving settings:', error);
+        throw error;
+    }
+});

package/dist/electron/preload.d.ts

@@ -46,4 +46,38 @@ export interface ElectronAPI {
     scanProjectPorts: (projectId: number) => Promise<ProjectPort[]>;
     scanAllPorts: () => Promise<Record<number, ProjectPort[]>>;
     getProjectPorts: (projectId: number) => Promise<ProjectPort[]>;
+    getRunningProcesses: () => Promise<Array<{
+        pid: number;
+        projectPath: string;
+        projectName: string;
+        scriptName: string;
+        command: string;
+        startedAt: number;
+        logFile: string;
+        detectedUrls?: string[];
+    }>>;
+    stopScript: (pid: number) => Promise<boolean>;
+    stopProject: (projectPath: string) => Promise<number>;
+    openUrl: (url: string) => Promise<void>;
+    openInEditor: (projectPath: string) => Promise<void>;
+    getSettings: () => Promise<{
+        editor: {
+            type: string;
+            customPath?: string;
+        };
+        browser: {
+            type: string;
+            customPath?: string;
+        };
+    }>;
+    saveSettings: (settings: {
+        editor: {
+            type: string;
+            customPath?: string;
+        };
+        browser: {
+            type: string;
+            customPath?: string;
+        };
+    }) => Promise<void>;
 }

package/dist/electron/preload.js

@@ -18,4 +18,11 @@ electron_1.contextBridge.exposeInMainWorld('electronAPI', {
     scanProjectPorts: (projectId) => electron_1.ipcRenderer.invoke('scan-project-ports', projectId),
     scanAllPorts: () => electron_1.ipcRenderer.invoke('scan-all-ports'),
     getProjectPorts: (projectId) => electron_1.ipcRenderer.invoke('get-project-ports', projectId),
+    getRunningProcesses: () => electron_1.ipcRenderer.invoke('get-running-processes'),
+    stopScript: (pid) => electron_1.ipcRenderer.invoke('stop-script', pid),
+    stopProject: (projectPath) => electron_1.ipcRenderer.invoke('stop-project', projectPath),
+    openUrl: (url) => electron_1.ipcRenderer.invoke('open-url', url),
+    openInEditor: (projectPath) => electron_1.ipcRenderer.invoke('open-in-editor', projectPath),
+    getSettings: () => electron_1.ipcRenderer.invoke('get-settings'),
+    saveSettings: (settings) => electron_1.ipcRenderer.invoke('save-settings', settings),
 });