projax 0.1.29

package/dist/core/detector.js

@@ -0,0 +1,149 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.FRAMEWORKS = void 0;
+exports.detectTestFramework = detectTestFramework;
+exports.isTestFile = isTestFile;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+exports.FRAMEWORKS = [
+    {
+        name: 'jest',
+        configFiles: ['jest.config.js', 'jest.config.ts', 'jest.config.json', 'jest.config.mjs', 'jest.config.cjs'],
+        testPatterns: [
+            /\.test\.(js|ts|jsx|tsx)$/i,
+            /\.spec\.(js|ts|jsx|tsx)$/i,
+        ],
+        testDirs: ['__tests__', '__test__'],
+    },
+    {
+        name: 'vitest',
+        configFiles: ['vitest.config.ts', 'vitest.config.js', 'vitest.config.mjs'],
+        testPatterns: [
+            /\.test\.(js|ts|jsx|tsx)$/i,
+            /\.spec\.(js|ts|jsx|tsx)$/i,
+        ],
+        testDirs: ['__tests__'],
+    },
+    {
+        name: 'mocha',
+        configFiles: ['.mocharc.js', '.mocharc.json', '.mocharc.yaml', '.mocharc.yml', 'mocha.opts'],
+        testPatterns: [
+            /\.test\.(js|ts|jsx|tsx)$/i,
+            /\.spec\.(js|ts|jsx|tsx)$/i,
+        ],
+        testDirs: ['test', 'tests'],
+    },
+];
+function detectTestFramework(projectPath) {
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    // Check package.json for test scripts and dependencies
+    if (fs.existsSync(packageJsonPath)) {
+        try {
+            const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+            // Check dependencies and devDependencies
+            const deps = { ...packageJson.dependencies, ...packageJson.devDependencies };
+            if (deps.jest)
+                return 'jest';
+            if (deps.vitest)
+                return 'vitest';
+            if (deps.mocha)
+                return 'mocha';
+            // Check for jest config in package.json
+            if (packageJson.jest)
+                return 'jest';
+            // Check test scripts
+            if (packageJson.scripts) {
+                const testScript = packageJson.scripts.test || '';
+                if (testScript.includes('jest'))
+                    return 'jest';
+                if (testScript.includes('vitest'))
+                    return 'vitest';
+                if (testScript.includes('mocha'))
+                    return 'mocha';
+            }
+        }
+        catch (error) {
+            // Invalid JSON, continue with file-based detection
+        }
+    }
+    // Check for config files
+    for (const framework of exports.FRAMEWORKS) {
+        for (const configFile of framework.configFiles) {
+            const configPath = path.join(projectPath, configFile);
+            if (fs.existsSync(configPath)) {
+                return framework.name;
+            }
+        }
+    }
+    return null;
+}
+function isTestFile(filePath, detectedFramework = null) {
+    const fileName = path.basename(filePath);
+    const dirName = path.dirname(filePath);
+    const parentDirName = path.basename(dirName);
+    // If framework is detected, use its specific patterns
+    if (detectedFramework) {
+        const framework = exports.FRAMEWORKS.find(f => f.name === detectedFramework);
+        if (framework) {
+            // Check test patterns
+            for (const pattern of framework.testPatterns) {
+                if (pattern.test(fileName)) {
+                    return true;
+                }
+            }
+            // Check test directories
+            for (const testDir of framework.testDirs) {
+                if (parentDirName === testDir) {
+                    return true;
+                }
+            }
+        }
+    }
+    // Fallback: check all common patterns
+    for (const framework of exports.FRAMEWORKS) {
+        for (const pattern of framework.testPatterns) {
+            if (pattern.test(fileName)) {
+                return true;
+            }
+        }
+        for (const testDir of framework.testDirs) {
+            if (parentDirName === testDir) {
+                return true;
+            }
+        }
+    }
+    return false;
+}

package/dist/core/index.d.ts

@@ -0,0 +1,11 @@
+export * from './database';
+export * from './detector';
+export * from './scanner';
+export { getDatabaseManager } from './database';
+import { Project, Test } from './database';
+import { scanProject, scanAllProjects } from './scanner';
+export declare function getAllProjects(): Project[];
+export declare function addProject(name: string, projectPath: string): Project;
+export declare function removeProject(id: number): void;
+export declare function getTestsByProject(projectId: number): Test[];
+export { scanProject, scanAllProjects };

package/dist/core/index.js

@@ -0,0 +1,43 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanAllProjects = exports.scanProject = exports.getDatabaseManager = void 0;
+exports.getAllProjects = getAllProjects;
+exports.addProject = addProject;
+exports.removeProject = removeProject;
+exports.getTestsByProject = getTestsByProject;
+__exportStar(require("./database"), exports);
+__exportStar(require("./detector"), exports);
+__exportStar(require("./scanner"), exports);
+var database_1 = require("./database");
+Object.defineProperty(exports, "getDatabaseManager", { enumerable: true, get: function () { return database_1.getDatabaseManager; } });
+// Convenience functions for common operations
+const database_2 = require("./database");
+const scanner_1 = require("./scanner");
+Object.defineProperty(exports, "scanProject", { enumerable: true, get: function () { return scanner_1.scanProject; } });
+Object.defineProperty(exports, "scanAllProjects", { enumerable: true, get: function () { return scanner_1.scanAllProjects; } });
+function getAllProjects() {
+    return (0, database_2.getDatabaseManager)().getAllProjects();
+}
+function addProject(name, projectPath) {
+    return (0, database_2.getDatabaseManager)().addProject(name, projectPath);
+}
+function removeProject(id) {
+    (0, database_2.getDatabaseManager)().removeProject(id);
+}
+function getTestsByProject(projectId) {
+    return (0, database_2.getDatabaseManager)().getTestsByProject(projectId);
+}

package/dist/core/scanner.d.ts

@@ -0,0 +1,8 @@
+import { Project, Test } from './database';
+export interface ScanResult {
+    project: Project;
+    testsFound: number;
+    tests: Test[];
+}
+export declare function scanProject(projectId: number): ScanResult;
+export declare function scanAllProjects(): ScanResult[];

package/dist/core/scanner.js

@@ -0,0 +1,114 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.scanProject = scanProject;
+exports.scanAllProjects = scanAllProjects;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const detector_1 = require("./detector");
+const database_1 = require("./database");
+function scanProject(projectId) {
+    const db = (0, database_1.getDatabaseManager)();
+    const project = db.getProject(projectId);
+    if (!project) {
+        throw new Error(`Project with id ${projectId} not found`);
+    }
+    if (!fs.existsSync(project.path)) {
+        throw new Error(`Project path does not exist: ${project.path}`);
+    }
+    // Detect framework first
+    const framework = (0, detector_1.detectTestFramework)(project.path);
+    // Remove existing tests for this project
+    db.removeTestsByProject(projectId);
+    // Scan for test files
+    const tests = [];
+    const testFiles = findTestFiles(project.path, framework);
+    for (const testFile of testFiles) {
+        const relativePath = path.relative(project.path, testFile);
+        const test = db.addTest(projectId, relativePath, framework);
+        tests.push(test);
+    }
+    // Update last scanned timestamp
+    db.updateProjectLastScanned(projectId);
+    return {
+        project: db.getProject(projectId),
+        testsFound: tests.length,
+        tests,
+    };
+}
+function findTestFiles(dir, framework, results = []) {
+    if (!fs.existsSync(dir)) {
+        return results;
+    }
+    const entries = fs.readdirSync(dir, { withFileTypes: true });
+    for (const entry of entries) {
+        const fullPath = path.join(dir, entry.name);
+        // Skip node_modules, .git, and other common ignore directories
+        if (entry.isDirectory()) {
+            if (entry.name === 'node_modules' ||
+                entry.name === '.git' ||
+                entry.name === 'dist' ||
+                entry.name === 'build' ||
+                entry.name === '.next' ||
+                entry.name === '.nuxt' ||
+                entry.name === 'coverage' ||
+                entry.name.startsWith('.')) {
+                continue;
+            }
+            findTestFiles(fullPath, framework, results);
+        }
+        else if (entry.isFile()) {
+            if ((0, detector_1.isTestFile)(fullPath, framework)) {
+                results.push(fullPath);
+            }
+        }
+    }
+    return results;
+}
+function scanAllProjects() {
+    const db = (0, database_1.getDatabaseManager)();
+    const projects = db.getAllProjects();
+    const results = [];
+    for (const project of projects) {
+        try {
+            const result = scanProject(project.id);
+            results.push(result);
+        }
+        catch (error) {
+            console.error(`Error scanning project ${project.name}:`, error);
+        }
+    }
+    return results;
+}

package/dist/electron/main.d.ts

@@ -0,0 +1 @@
+export {};

package/dist/electron/main.js

@@ -0,0 +1,310 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+const electron_1 = require("electron");
+const path = __importStar(require("path"));
+const fs = __importStar(require("fs"));
+// Import from bundled core in CLI package, or fallback to @projax/core
+let coreModule;
+try {
+    // Try relative import first (when bundled in CLI: dist/electron/main.js -> dist/core)
+    coreModule = require('../core');
+}
+catch {
+    try {
+        // Try alternative path (local development: packages/electron/dist/main.js -> packages/cli/dist/core)
+        coreModule = require('../../cli/dist/core');
+    }
+    catch {
+        // Fallback to package import
+        coreModule = require('@projax/core');
+    }
+}
+const { getDatabaseManager, getAllProjects, addProject, removeProject, scanProject, scanAllProjects, getTestsByProject, } = coreModule;
+let mainWindow = null;
+// Prevent multiple instances
+const gotTheLock = electron_1.app.requestSingleInstanceLock();
+if (!gotTheLock) {
+    electron_1.app.quit();
+}
+else {
+    electron_1.app.on('second-instance', () => {
+        // Someone tried to run a second instance, focus our window instead
+        if (mainWindow) {
+            if (mainWindow.isMinimized())
+                mainWindow.restore();
+            mainWindow.focus();
+        }
+    });
+    function createWindow() {
+        // Don't create a new window if one already exists
+        if (mainWindow) {
+            mainWindow.focus();
+            return;
+        }
+        const isDev = process.env.NODE_ENV === 'development';
+        mainWindow = new electron_1.BrowserWindow({
+            width: 1200,
+            height: 800,
+            frame: false,
+            titleBarStyle: process.platform === 'darwin' ? 'hidden' : 'hidden',
+            webPreferences: {
+                preload: path.join(__dirname, 'preload.js'),
+                nodeIntegration: false,
+                contextIsolation: true,
+            },
+        });
+        // Load the app
+        if (isDev) {
+            mainWindow.loadURL('http://localhost:7898');
+            mainWindow.webContents.openDevTools();
+        }
+        else {
+            // Try bundled renderer path first (when bundled in CLI: dist/electron/renderer/index.html)
+            // Then try local dev path (packages/electron/dist/renderer/index.html)
+            const bundledRenderer = path.join(__dirname, 'renderer', 'index.html');
+            const localRenderer = path.join(__dirname, '..', 'renderer', 'index.html');
+            if (fs.existsSync(bundledRenderer)) {
+                mainWindow.loadFile(bundledRenderer);
+            }
+            else if (fs.existsSync(localRenderer)) {
+                mainWindow.loadFile(localRenderer);
+            }
+            else {
+                console.error('Error: Renderer index.html not found');
+                console.error('Bundled path:', bundledRenderer);
+                console.error('Local path:', localRenderer);
+                electron_1.app.quit();
+            }
+        }
+        mainWindow.on('closed', () => {
+            mainWindow = null;
+        });
+    }
+    electron_1.app.whenReady().then(() => {
+        createWindow();
+        electron_1.app.on('activate', () => {
+            // On macOS, re-create window when dock icon is clicked and no windows are open
+            if (electron_1.BrowserWindow.getAllWindows().length === 0) {
+                createWindow();
+            }
+            else if (mainWindow) {
+                mainWindow.focus();
+            }
+        });
+    });
+}
+electron_1.app.on('window-all-closed', () => {
+    if (process.platform !== 'darwin') {
+        electron_1.app.quit();
+    }
+});
+// IPC Handlers
+electron_1.ipcMain.handle('get-projects', async () => {
+    try {
+        console.log('Getting projects from database...');
+        const projects = getAllProjects();
+        console.log(`Found ${projects.length} project(s)`);
+        return projects;
+    }
+    catch (error) {
+        console.error('Error getting projects:', error);
+        throw error;
+    }
+});
+electron_1.ipcMain.handle('add-project', async (_, projectPath) => {
+    if (!fs.existsSync(projectPath)) {
+        throw new Error('Path does not exist');
+    }
+    if (!fs.statSync(projectPath).isDirectory()) {
+        throw new Error('Path must be a directory');
+    }
+    const db = getDatabaseManager();
+    const existingProject = db.getProjectByPath(projectPath);
+    if (existingProject) {
+        throw new Error('Project already exists');
+    }
+    const projectName = path.basename(projectPath);
+    return db.addProject(projectName, projectPath);
+});
+electron_1.ipcMain.handle('remove-project', async (_, projectId) => {
+    removeProject(projectId);
+});
+electron_1.ipcMain.handle('scan-project', async (_, projectId) => {
+    return scanProject(projectId);
+});
+electron_1.ipcMain.handle('scan-all-projects', async () => {
+    return scanAllProjects();
+});
+electron_1.ipcMain.handle('get-tests', async (_, projectId) => {
+    try {
+        const db = getDatabaseManager();
+        return getTestsByProject(projectId);
+    }
+    catch (error) {
+        console.error('Error getting tests:', error);
+        throw error;
+    }
+});
+electron_1.ipcMain.handle('select-directory', async () => {
+    if (!mainWindow)
+        return null;
+    const result = await electron_1.dialog.showOpenDialog(mainWindow, {
+        properties: ['openDirectory'],
+    });
+    if (result.canceled || result.filePaths.length === 0) {
+        return null;
+    }
+    return result.filePaths[0];
+});
+// Window controls
+electron_1.ipcMain.handle('minimize-window', () => {
+    if (mainWindow) {
+        mainWindow.minimize();
+    }
+});
+electron_1.ipcMain.handle('maximize-window', () => {
+    if (mainWindow) {
+        if (mainWindow.isMaximized()) {
+            mainWindow.unmaximize();
+        }
+        else {
+            mainWindow.maximize();
+        }
+    }
+});
+electron_1.ipcMain.handle('close-window', () => {
+    if (mainWindow) {
+        mainWindow.close();
+    }
+});
+// Rename project
+electron_1.ipcMain.handle('rename-project', async (_, projectId, newName) => {
+    const db = getDatabaseManager();
+    return db.updateProjectName(projectId, newName);
+});
+// Get project scripts
+electron_1.ipcMain.handle('get-project-scripts', 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 { getProjectScripts } = await Promise.resolve(`${scriptRunnerPath}`).then(s => __importStar(require(s)));
+    const result = getProjectScripts(projectPath);
+    // Convert Map to array for IPC serialization
+    const scriptsArray = Array.from(result.scripts.entries()).map(([name, script]) => ({
+        name,
+        ...script,
+    }));
+    return {
+        type: result.type,
+        scripts: scriptsArray,
+    };
+});
+// Run script
+electron_1.ipcMain.handle('run-script', async (_, projectPath, scriptName, args = [], background = false) => {
+    // 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 { runScriptInBackground } = await Promise.resolve(`${scriptRunnerPath}`).then(s => __importStar(require(s)));
+    const db = getDatabaseManager();
+    const project = db.getProjectByPath(projectPath);
+    if (!project) {
+        throw new Error('Project not found');
+    }
+    // Run in background (foreground scripts would need IPC streaming for output)
+    await runScriptInBackground(projectPath, project.name, scriptName, args, false);
+    return { success: true, background: true };
+});
+// 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/electron/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)));
+    await scanProjectPorts(projectId);
+    const db = 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/electron/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)));
+    await scanAllProjectPorts();
+    const db = getDatabaseManager();
+    const projects = getAllProjects();
+    const result = {};
+    for (const project of projects) {
+        result[project.id] = db.getProjectPorts(project.id);
+    }
+    return result;
+});
+// Get project ports
+electron_1.ipcMain.handle('get-project-ports', async (_, projectId) => {
+    const db = getDatabaseManager();
+    return db.getProjectPorts(projectId);
+});

package/dist/electron/port-extractor.d.ts

@@ -0,0 +1,9 @@
+export interface PortInfo {
+    port: number;
+    script: string | null;
+    source: string;
+}
+/**
+ * Extract ports from a project's configuration files
+ */
+export declare function extractPortsFromProject(projectPath: string): Promise<PortInfo[]>;