projax 0.1.29

package/dist/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[]>;

package/dist/port-extractor.js

@@ -0,0 +1,351 @@
+"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.extractPortsFromProject = extractPortsFromProject;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+/**
+ * Extract ports from a project's configuration files
+ */
+async function extractPortsFromProject(projectPath) {
+    const ports = [];
+    // Extract from package.json scripts
+    const packageJsonPorts = extractPortsFromPackageJson(projectPath);
+    ports.push(...packageJsonPorts);
+    // Extract from vite.config.js/ts
+    const vitePorts = extractPortsFromViteConfig(projectPath);
+    ports.push(...vitePorts);
+    // Extract from next.config.js/ts
+    const nextPorts = extractPortsFromNextConfig(projectPath);
+    ports.push(...nextPorts);
+    // Extract from webpack.config.js
+    const webpackPorts = extractPortsFromWebpackConfig(projectPath);
+    ports.push(...webpackPorts);
+    // Extract from angular.json
+    const angularPorts = extractPortsFromAngularConfig(projectPath);
+    ports.push(...angularPorts);
+    // Extract from nuxt.config.js/ts
+    const nuxtPorts = extractPortsFromNuxtConfig(projectPath);
+    ports.push(...nuxtPorts);
+    // Extract from .env files
+    const envPorts = extractPortsFromEnvFiles(projectPath);
+    ports.push(...envPorts);
+    // Remove duplicates (same port and script)
+    const uniquePorts = Array.from(new Map(ports.map(p => [`${p.port}-${p.script || ''}`, p])).values());
+    return uniquePorts;
+}
+/**
+ * Extract ports from package.json scripts
+ */
+function extractPortsFromPackageJson(projectPath) {
+    const ports = [];
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        return ports;
+    }
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        const scripts = packageJson.scripts || {};
+        for (const [scriptName, scriptCommand] of Object.entries(scripts)) {
+            if (typeof scriptCommand === 'string') {
+                // Look for --port, -p, PORT= patterns
+                const portPatterns = [
+                    /--port\s+(\d+)/i,
+                    /-p\s+(\d+)/i,
+                    /PORT\s*=\s*(\d+)/i,
+                    /VITE_PORT\s*=\s*(\d+)/i,
+                    /NEXT_PORT\s*=\s*(\d+)/i,
+                    /PORT=(\d+)/i,
+                ];
+                for (const pattern of portPatterns) {
+                    const match = scriptCommand.match(pattern);
+                    if (match && match[1]) {
+                        const port = parseInt(match[1], 10);
+                        if (!isNaN(port) && port > 0 && port <= 65535) {
+                            ports.push({
+                                port,
+                                script: scriptName,
+                                source: 'package.json',
+                            });
+                            break; // Only add once per script
+                        }
+                    }
+                }
+            }
+        }
+    }
+    catch (error) {
+        // Ignore parsing errors
+    }
+    return ports;
+}
+/**
+ * Extract ports from vite.config.js/ts
+ */
+function extractPortsFromViteConfig(projectPath) {
+    const ports = [];
+    const configFiles = [
+        'vite.config.js',
+        'vite.config.ts',
+        'vite.config.mjs',
+        'vite.config.cjs',
+    ];
+    for (const configFile of configFiles) {
+        const configPath = path.join(projectPath, configFile);
+        if (!fs.existsSync(configPath))
+            continue;
+        try {
+            const content = fs.readFileSync(configPath, 'utf-8');
+            // Try to extract from server.port
+            const patterns = [
+                /server\s*:\s*\{[^}]*port\s*:\s*(\d+)/i,
+                /server\s*:\s*\{[^}]*port\s*:\s*['"](\d+)['"]/i,
+                /port\s*:\s*(\d+)/i,
+                /port\s*:\s*['"](\d+)['"]/i,
+            ];
+            for (const pattern of patterns) {
+                const match = content.match(pattern);
+                if (match && match[1]) {
+                    const port = parseInt(match[1], 10);
+                    if (!isNaN(port) && port > 0 && port <= 65535) {
+                        ports.push({
+                            port,
+                            script: null,
+                            source: configFile,
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Ignore parsing errors
+        }
+    }
+    return ports;
+}
+/**
+ * Extract ports from next.config.js/ts
+ */
+function extractPortsFromNextConfig(projectPath) {
+    const ports = [];
+    const configFiles = ['next.config.js', 'next.config.ts', 'next.config.mjs'];
+    for (const configFile of configFiles) {
+        const configPath = path.join(projectPath, configFile);
+        if (!fs.existsSync(configPath))
+            continue;
+        try {
+            const content = fs.readFileSync(configPath, 'utf-8');
+            // Next.js doesn't typically configure port in config, but check for devServer
+            const patterns = [
+                /devServer\s*:\s*\{[^}]*port\s*:\s*(\d+)/i,
+                /port\s*:\s*(\d+)/i,
+            ];
+            for (const pattern of patterns) {
+                const match = content.match(pattern);
+                if (match && match[1]) {
+                    const port = parseInt(match[1], 10);
+                    if (!isNaN(port) && port > 0 && port <= 65535) {
+                        ports.push({
+                            port,
+                            script: null,
+                            source: configFile,
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Ignore parsing errors
+        }
+    }
+    return ports;
+}
+/**
+ * Extract ports from webpack.config.js
+ */
+function extractPortsFromWebpackConfig(projectPath) {
+    const ports = [];
+    const configFiles = ['webpack.config.js', 'webpack.config.ts'];
+    for (const configFile of configFiles) {
+        const configPath = path.join(projectPath, configFile);
+        if (!fs.existsSync(configPath))
+            continue;
+        try {
+            const content = fs.readFileSync(configPath, 'utf-8');
+            // Look for devServer.port
+            const patterns = [
+                /devServer\s*:\s*\{[^}]*port\s*:\s*(\d+)/i,
+                /devServer\s*:\s*\{[^}]*port\s*:\s*['"](\d+)['"]/i,
+            ];
+            for (const pattern of patterns) {
+                const match = content.match(pattern);
+                if (match && match[1]) {
+                    const port = parseInt(match[1], 10);
+                    if (!isNaN(port) && port > 0 && port <= 65535) {
+                        ports.push({
+                            port,
+                            script: null,
+                            source: configFile,
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Ignore parsing errors
+        }
+    }
+    return ports;
+}
+/**
+ * Extract ports from angular.json
+ */
+function extractPortsFromAngularConfig(projectPath) {
+    const ports = [];
+    const configPath = path.join(projectPath, 'angular.json');
+    if (!fs.existsSync(configPath)) {
+        return ports;
+    }
+    try {
+        const angularJson = JSON.parse(fs.readFileSync(configPath, 'utf-8'));
+        // Navigate through projects -> architect -> serve -> options -> port
+        const projects = angularJson.projects || {};
+        for (const projectName of Object.keys(projects)) {
+            const project = projects[projectName];
+            const serve = project?.architect?.serve;
+            if (serve?.options?.port) {
+                const port = parseInt(serve.options.port, 10);
+                if (!isNaN(port) && port > 0 && port <= 65535) {
+                    ports.push({
+                        port,
+                        script: null,
+                        source: 'angular.json',
+                    });
+                }
+            }
+        }
+    }
+    catch (error) {
+        // Ignore parsing errors
+    }
+    return ports;
+}
+/**
+ * Extract ports from nuxt.config.js/ts
+ */
+function extractPortsFromNuxtConfig(projectPath) {
+    const ports = [];
+    const configFiles = ['nuxt.config.js', 'nuxt.config.ts'];
+    for (const configFile of configFiles) {
+        const configPath = path.join(projectPath, configFile);
+        if (!fs.existsSync(configPath))
+            continue;
+        try {
+            const content = fs.readFileSync(configPath, 'utf-8');
+            // Look for server.port
+            const patterns = [
+                /server\s*:\s*\{[^}]*port\s*:\s*(\d+)/i,
+                /server\s*:\s*\{[^}]*port\s*:\s*['"](\d+)['"]/i,
+            ];
+            for (const pattern of patterns) {
+                const match = content.match(pattern);
+                if (match && match[1]) {
+                    const port = parseInt(match[1], 10);
+                    if (!isNaN(port) && port > 0 && port <= 65535) {
+                        ports.push({
+                            port,
+                            script: null,
+                            source: configFile,
+                        });
+                        break;
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Ignore parsing errors
+        }
+    }
+    return ports;
+}
+/**
+ * Extract ports from .env files
+ */
+function extractPortsFromEnvFiles(projectPath) {
+    const ports = [];
+    const envFiles = ['.env', '.env.local', '.env.development', '.env.production'];
+    for (const envFile of envFiles) {
+        const envPath = path.join(projectPath, envFile);
+        if (!fs.existsSync(envPath))
+            continue;
+        try {
+            const content = fs.readFileSync(envPath, 'utf-8');
+            const lines = content.split('\n');
+            for (const line of lines) {
+                // Skip comments
+                if (line.trim().startsWith('#'))
+                    continue;
+                // Look for PORT=, VITE_PORT=, NEXT_PORT=, etc.
+                const patterns = [
+                    /^PORT\s*=\s*(\d+)/i,
+                    /^VITE_PORT\s*=\s*(\d+)/i,
+                    /^NEXT_PORT\s*=\s*(\d+)/i,
+                    /^REACT_APP_PORT\s*=\s*(\d+)/i,
+                ];
+                for (const pattern of patterns) {
+                    const match = line.match(pattern);
+                    if (match && match[1]) {
+                        const port = parseInt(match[1], 10);
+                        if (!isNaN(port) && port > 0 && port <= 65535) {
+                            ports.push({
+                                port,
+                                script: null,
+                                source: envFile,
+                            });
+                            break;
+                        }
+                    }
+                }
+            }
+        }
+        catch (error) {
+            // Ignore parsing errors
+        }
+    }
+    return ports;
+}

package/dist/port-scanner.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Scan and index ports for a specific project
+ */
+export declare function scanProjectPorts(projectId: number): Promise<void>;
+/**
+ * Scan ports for all projects
+ */
+export declare function scanAllProjectPorts(): Promise<void>;
+/**
+ * Check if ports need to be rescanned (stale check)
+ * Returns true if ports haven't been scanned in the last 24 hours
+ */
+export declare function shouldRescanPorts(projectId: number): boolean;

package/dist/port-scanner.js

@@ -0,0 +1,93 @@
+"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.scanProjectPorts = scanProjectPorts;
+exports.scanAllProjectPorts = scanAllProjectPorts;
+exports.shouldRescanPorts = shouldRescanPorts;
+const core_1 = require("./core");
+const port_extractor_1 = require("./port-extractor");
+const fs = __importStar(require("fs"));
+/**
+ * Scan and index ports for a specific project
+ */
+async function scanProjectPorts(projectId) {
+    const db = (0, core_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}`);
+    }
+    // Extract ports from project
+    const ports = await (0, port_extractor_1.extractPortsFromProject)(project.path);
+    // Remove existing ports for this project
+    db.removeProjectPorts(projectId);
+    // Add new ports
+    for (const portInfo of ports) {
+        db.addProjectPort(projectId, portInfo.port, portInfo.source, portInfo.script);
+    }
+}
+/**
+ * Scan ports for all projects
+ */
+async function scanAllProjectPorts() {
+    const db = (0, core_1.getDatabaseManager)();
+    const projects = db.getAllProjects();
+    for (const project of projects) {
+        try {
+            await scanProjectPorts(project.id);
+        }
+        catch (error) {
+            // Continue with other projects if one fails
+            console.error(`Error scanning ports for project ${project.name}:`, error instanceof Error ? error.message : error);
+        }
+    }
+}
+/**
+ * Check if ports need to be rescanned (stale check)
+ * Returns true if ports haven't been scanned in the last 24 hours
+ */
+function shouldRescanPorts(projectId) {
+    const db = (0, core_1.getDatabaseManager)();
+    const ports = db.getProjectPorts(projectId);
+    if (ports.length === 0) {
+        return true; // No ports found, should scan
+    }
+    // Check if any port was detected more than 24 hours ago
+    const twentyFourHoursAgo = Math.floor(Date.now() / 1000) - (24 * 60 * 60);
+    const needsRescan = ports.some(port => (port.last_detected || 0) < twentyFourHoursAgo);
+    return needsRescan;
+}

package/dist/port-utils.d.ts

@@ -0,0 +1,21 @@
+export interface ProcessInfo {
+    pid: number;
+    command: string;
+}
+/**
+ * Check if a port is in use (cross-platform)
+ */
+export declare function detectPortInUse(port: number): Promise<boolean>;
+/**
+ * Get process information for a port (cross-platform)
+ */
+export declare function getProcessOnPort(port: number): Promise<ProcessInfo | null>;
+/**
+ * Kill process(es) using a port (cross-platform)
+ */
+export declare function killProcessOnPort(port: number): Promise<boolean>;
+/**
+ * Extract port number from error messages
+ * Handles common port conflict error patterns
+ */
+export declare function extractPortFromError(error: string): number | null;

package/dist/port-utils.js

@@ -0,0 +1,200 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.detectPortInUse = detectPortInUse;
+exports.getProcessOnPort = getProcessOnPort;
+exports.killProcessOnPort = killProcessOnPort;
+exports.extractPortFromError = extractPortFromError;
+const child_process_1 = require("child_process");
+const util_1 = require("util");
+const execAsync = (0, util_1.promisify)(child_process_1.exec);
+/**
+ * Check if a port is in use (cross-platform)
+ */
+async function detectPortInUse(port) {
+    try {
+        if (process.platform === 'win32') {
+            // Windows: Use netstat
+            const { stdout } = await execAsync(`netstat -ano | findstr :${port}`);
+            return stdout.trim().length > 0;
+        }
+        else {
+            // macOS/Linux: Use lsof
+            try {
+                const { stdout } = await execAsync(`lsof -ti:${port}`);
+                return stdout.trim().length > 0;
+            }
+            catch (error) {
+                // lsof returns non-zero exit code when port is not in use
+                if (error.code === 1) {
+                    return false;
+                }
+                // Try netstat as fallback
+                try {
+                    const { stdout } = await execAsync(`netstat -an | grep :${port}`);
+                    return stdout.trim().length > 0;
+                }
+                catch {
+                    return false;
+                }
+            }
+        }
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Get process information for a port (cross-platform)
+ */
+async function getProcessOnPort(port) {
+    try {
+        if (process.platform === 'win32') {
+            // Windows: Get PID from netstat, then get process name
+            const { stdout: netstatOutput } = await execAsync(`netstat -ano | findstr :${port}`);
+            const lines = netstatOutput.trim().split('\n');
+            if (lines.length === 0)
+                return null;
+            // Parse PID from netstat output (last column)
+            const pidMatch = lines[0].trim().split(/\s+/).pop();
+            if (!pidMatch)
+                return null;
+            const pid = parseInt(pidMatch, 10);
+            if (isNaN(pid))
+                return null;
+            // Get process name
+            try {
+                const { stdout: tasklistOutput } = await execAsync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`);
+                const parts = tasklistOutput.trim().split(',');
+                const command = parts[0]?.replace(/"/g, '') || 'unknown';
+                return { pid, command };
+            }
+            catch {
+                return { pid, command: 'unknown' };
+            }
+        }
+        else {
+            // macOS/Linux: Use lsof
+            try {
+                const { stdout } = await execAsync(`lsof -ti:${port} -sTCP:LISTEN`);
+                const pids = stdout.trim().split('\n').filter(Boolean);
+                if (pids.length === 0)
+                    return null;
+                const pid = parseInt(pids[0], 10);
+                if (isNaN(pid))
+                    return null;
+                // Get process command
+                try {
+                    const { stdout: psOutput } = await execAsync(`ps -p ${pid} -o comm=`);
+                    const command = psOutput.trim() || 'unknown';
+                    return { pid, command };
+                }
+                catch {
+                    return { pid, command: 'unknown' };
+                }
+            }
+            catch (error) {
+                if (error.code === 1) {
+                    return null;
+                }
+                throw error;
+            }
+        }
+    }
+    catch (error) {
+        return null;
+    }
+}
+/**
+ * Kill process(es) using a port (cross-platform)
+ */
+async function killProcessOnPort(port) {
+    try {
+        if (process.platform === 'win32') {
+            // Windows: Get PID and kill with taskkill
+            const { stdout: netstatOutput } = await execAsync(`netstat -ano | findstr :${port}`);
+            const lines = netstatOutput.trim().split('\n');
+            if (lines.length === 0)
+                return false;
+            const pids = new Set();
+            for (const line of lines) {
+                const parts = line.trim().split(/\s+/);
+                const pid = parseInt(parts[parts.length - 1], 10);
+                if (!isNaN(pid)) {
+                    pids.add(pid);
+                }
+            }
+            let killed = false;
+            for (const pid of pids) {
+                try {
+                    await execAsync(`taskkill /F /PID ${pid}`);
+                    killed = true;
+                }
+                catch {
+                    // Ignore errors for individual PIDs
+                }
+            }
+            return killed;
+        }
+        else {
+            // macOS/Linux: Use lsof to find PIDs and kill them
+            try {
+                const { stdout } = await execAsync(`lsof -ti:${port}`);
+                const pids = stdout.trim().split('\n').filter(Boolean);
+                if (pids.length === 0)
+                    return false;
+                let killed = false;
+                for (const pidStr of pids) {
+                    const pid = parseInt(pidStr, 10);
+                    if (!isNaN(pid)) {
+                        try {
+                            await execAsync(`kill -9 ${pid}`);
+                            killed = true;
+                        }
+                        catch {
+                            // Ignore errors for individual PIDs
+                        }
+                    }
+                }
+                return killed;
+            }
+            catch (error) {
+                if (error.code === 1) {
+                    return false; // Port not in use
+                }
+                throw error;
+            }
+        }
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Extract port number from error messages
+ * Handles common port conflict error patterns
+ */
+function extractPortFromError(error) {
+    // Common patterns:
+    // - "EADDRINUSE: address already in use :::3000"
+    // - "Port 3000 is already in use"
+    // - "Error: listen EADDRINUSE: address already in use 0.0.0.0:3000"
+    // - "Address already in use: 3000"
+    // - "port 3000 is already in use by another process"
+    const patterns = [
+        /(?:port|Port)\s+(\d+)\s+(?:is\s+)?(?:already\s+)?(?:in\s+use|taken)/i,
+        /EADDRINUSE[^:]*:\s*(?:address\s+already\s+in\s+use[^:]*:)?\s*(?:::|0\.0\.0\.0|127\.0\.0\.1|localhost)?:?(\d+)/i,
+        /(?:address|Address)\s+already\s+in\s+use[^:]*:?\s*(\d+)/i,
+        /(?:listen|Listen)\s+EADDRINUSE[^:]*:\s*(?:address\s+already\s+in\s+use[^:]*:)?\s*(?:::|0\.0\.0\.0|127\.0\.0\.1|localhost)?:?(\d+)/i,
+        /:(\d+)\s+\(EADDRINUSE\)/i,
+    ];
+    for (const pattern of patterns) {
+        const match = error.match(pattern);
+        if (match && match[1]) {
+            const port = parseInt(match[1], 10);
+            if (!isNaN(port) && port > 0 && port <= 65535) {
+                return port;
+            }
+        }
+    }
+    return null;
+}