projax 0.1.29 → 1.0.0

package/dist/electron/main.js

@@ -308,3 +308,217 @@ 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 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 { getAppSettings } = await Promise.resolve(`${corePath}`).then(s => __importStar(require(s)));
+    return getAppSettings();
+});
+// Save settings
+electron_1.ipcMain.handle('save-settings', async (_, settings) => {
+    // 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 { setAppSettings } = await Promise.resolve(`${corePath}`).then(s => __importStar(require(s)));
+    setAppSettings(settings);
+});

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),
 });