projax 0.1.29

package/dist/electron/script-runner.js

@@ -0,0 +1,651 @@
+"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.detectProjectType = detectProjectType;
+exports.getProjectScripts = getProjectScripts;
+exports.runScript = runScript;
+exports.getProjectProcesses = getProjectProcesses;
+exports.runScriptInBackground = runScriptInBackground;
+const fs = __importStar(require("fs"));
+const path = __importStar(require("path"));
+const os = __importStar(require("os"));
+const child_process_1 = require("child_process");
+const core_1 = require("./core");
+const port_utils_1 = require("./port-utils");
+/**
+ * Detect the project type based on files in the directory
+ */
+function detectProjectType(projectPath) {
+    if (fs.existsSync(path.join(projectPath, 'package.json'))) {
+        return 'node';
+    }
+    if (fs.existsSync(path.join(projectPath, 'pyproject.toml'))) {
+        return 'python';
+    }
+    if (fs.existsSync(path.join(projectPath, 'Cargo.toml'))) {
+        return 'rust';
+    }
+    if (fs.existsSync(path.join(projectPath, 'go.mod'))) {
+        return 'go';
+    }
+    if (fs.existsSync(path.join(projectPath, 'Makefile')) || fs.existsSync(path.join(projectPath, 'makefile'))) {
+        return 'makefile';
+    }
+    return 'unknown';
+}
+/**
+ * Parse scripts from package.json (Node.js)
+ */
+function parseNodeScripts(projectPath) {
+    const packageJsonPath = path.join(projectPath, 'package.json');
+    if (!fs.existsSync(packageJsonPath)) {
+        return new Map();
+    }
+    try {
+        const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf-8'));
+        const scripts = packageJson.scripts || {};
+        const scriptMap = new Map();
+        for (const [name, command] of Object.entries(scripts)) {
+            if (typeof command === 'string') {
+                scriptMap.set(name, {
+                    name,
+                    command: command,
+                    runner: 'npm',
+                    projectType: 'node',
+                });
+            }
+        }
+        return scriptMap;
+    }
+    catch (error) {
+        return new Map();
+    }
+}
+/**
+ * Parse scripts from pyproject.toml (Python)
+ */
+function parsePythonScripts(projectPath) {
+    const pyprojectPath = path.join(projectPath, 'pyproject.toml');
+    if (!fs.existsSync(pyprojectPath)) {
+        return new Map();
+    }
+    try {
+        const content = fs.readFileSync(pyprojectPath, 'utf-8');
+        const scriptMap = new Map();
+        // Simple TOML parsing for [project.scripts] section
+        // This is a basic implementation - for production, consider using a TOML parser
+        const scriptsMatch = content.match(/\[project\.scripts\]\s*\n((?:[^\[]+\n?)+)/);
+        if (scriptsMatch) {
+            const scriptsSection = scriptsMatch[1];
+            const scriptLines = scriptsSection.split('\n');
+            for (const line of scriptLines) {
+                const match = line.match(/^(\w+)\s*=\s*["']([^"']+)["']/);
+                if (match) {
+                    const [, name, command] = match;
+                    scriptMap.set(name, {
+                        name,
+                        command,
+                        runner: 'python',
+                        projectType: 'python',
+                    });
+                }
+            }
+        }
+        // Also check for [tool.poetry.scripts]
+        const poetryMatch = content.match(/\[tool\.poetry\.scripts\]\s*\n((?:[^\[]+\n?)+)/);
+        if (poetryMatch) {
+            const scriptsSection = poetryMatch[1];
+            const scriptLines = scriptsSection.split('\n');
+            for (const line of scriptLines) {
+                const match = line.match(/^(\w+)\s*=\s*["']([^"']+)["']/);
+                if (match) {
+                    const [, name, command] = match;
+                    scriptMap.set(name, {
+                        name,
+                        command,
+                        runner: 'poetry',
+                        projectType: 'python',
+                    });
+                }
+            }
+        }
+        return scriptMap;
+    }
+    catch (error) {
+        return new Map();
+    }
+}
+/**
+ * Parse scripts from Cargo.toml (Rust)
+ * Cargo doesn't have a scripts section, but we can detect common cargo commands
+ */
+function parseRustScripts(projectPath) {
+    const scriptMap = new Map();
+    // Common cargo commands that can be run
+    const commonCommands = [
+        { name: 'build', command: 'cargo build', runner: 'cargo' },
+        { name: 'run', command: 'cargo run', runner: 'cargo' },
+        { name: 'test', command: 'cargo test', runner: 'cargo' },
+        { name: 'check', command: 'cargo check', runner: 'cargo' },
+        { name: 'clippy', command: 'cargo clippy', runner: 'cargo' },
+        { name: 'fmt', command: 'cargo fmt', runner: 'cargo' },
+    ];
+    for (const cmd of commonCommands) {
+        scriptMap.set(cmd.name, {
+            name: cmd.name,
+            command: cmd.command,
+            runner: cmd.runner,
+            projectType: 'rust',
+        });
+    }
+    return scriptMap;
+}
+/**
+ * Parse Makefile targets
+ */
+function parseMakefileScripts(projectPath) {
+    const makefilePath = fs.existsSync(path.join(projectPath, 'Makefile'))
+        ? path.join(projectPath, 'Makefile')
+        : path.join(projectPath, 'makefile');
+    if (!fs.existsSync(makefilePath)) {
+        return new Map();
+    }
+    try {
+        const content = fs.readFileSync(makefilePath, 'utf-8');
+        const scriptMap = new Map();
+        // Parse Makefile targets (basic implementation)
+        // Match lines that look like targets: target: dependencies
+        const targetRegex = /^([a-zA-Z0-9_-]+)\s*:.*$/gm;
+        let match;
+        while ((match = targetRegex.exec(content)) !== null) {
+            const targetName = match[1];
+            // Skip special targets
+            if (!targetName.startsWith('.') && targetName !== 'PHONY') {
+                scriptMap.set(targetName, {
+                    name: targetName,
+                    command: `make ${targetName}`,
+                    runner: 'make',
+                    projectType: 'makefile',
+                });
+            }
+        }
+        return scriptMap;
+    }
+    catch (error) {
+        return new Map();
+    }
+}
+/**
+ * Get all available scripts for a project
+ */
+function getProjectScripts(projectPath) {
+    const type = detectProjectType(projectPath);
+    let scripts = new Map();
+    switch (type) {
+        case 'node':
+            scripts = parseNodeScripts(projectPath);
+            break;
+        case 'python':
+            scripts = parsePythonScripts(projectPath);
+            break;
+        case 'rust':
+            scripts = parseRustScripts(projectPath);
+            break;
+        case 'makefile':
+            scripts = parseMakefileScripts(projectPath);
+            break;
+        case 'go':
+            // Go projects typically use Makefile or direct go commands
+            // Check for Makefile first, otherwise provide common go commands
+            const makefileScripts = parseMakefileScripts(projectPath);
+            if (makefileScripts.size > 0) {
+                scripts = makefileScripts;
+            }
+            else {
+                // Common go commands
+                scripts.set('run', {
+                    name: 'run',
+                    command: 'go run .',
+                    runner: 'go',
+                    projectType: 'go',
+                });
+                scripts.set('build', {
+                    name: 'build',
+                    command: 'go build',
+                    runner: 'go',
+                    projectType: 'go',
+                });
+                scripts.set('test', {
+                    name: 'test',
+                    command: 'go test ./...',
+                    runner: 'go',
+                    projectType: 'go',
+                });
+            }
+            break;
+        default:
+            // For unknown projects, check for Makefile as fallback
+            scripts = parseMakefileScripts(projectPath);
+            break;
+    }
+    return {
+        type,
+        scripts,
+    };
+}
+/**
+ * Handle port conflict - prompt user or auto-kill based on force flag
+ */
+async function handlePortConflict(port, projectName, force) {
+    const processInfo = await (0, port_utils_1.getProcessOnPort)(port);
+    if (!processInfo) {
+        console.error(`Port ${port} appears to be in use, but couldn't identify the process.`);
+        return false;
+    }
+    console.error(`\n⚠️  Port ${port} is already in use by process ${processInfo.pid} (${processInfo.command})`);
+    if (force) {
+        console.log(`Killing process ${processInfo.pid} on port ${port}...`);
+        const killed = await (0, port_utils_1.killProcessOnPort)(port);
+        if (killed) {
+            console.log(`✓ Process killed. Retrying...\n`);
+            return true;
+        }
+        else {
+            console.error(`Failed to kill process on port ${port}`);
+            return false;
+        }
+    }
+    else {
+        const inquirer = (await Promise.resolve().then(() => __importStar(require('inquirer')))).default;
+        const answer = await inquirer.prompt([
+            {
+                type: 'confirm',
+                name: 'kill',
+                message: `Kill process ${processInfo.pid} (${processInfo.command}) and continue?`,
+                default: false,
+            },
+        ]);
+        if (answer.kill) {
+            const killed = await (0, port_utils_1.killProcessOnPort)(port);
+            if (killed) {
+                console.log(`✓ Process killed. Retrying...\n`);
+                return true;
+            }
+            else {
+                console.error(`Failed to kill process on port ${port}`);
+                return false;
+            }
+        }
+        else {
+            console.log('Cancelled.');
+            return false;
+        }
+    }
+}
+/**
+ * Check ports proactively before script execution
+ */
+async function checkPortsBeforeExecution(projectPath, scriptName, force) {
+    const db = (0, core_1.getDatabaseManager)();
+    const project = db.getProjectByPath(projectPath);
+    if (!project)
+        return true; // Can't check if project not in DB
+    const ports = db.getProjectPortsByScript(project.id, scriptName);
+    if (ports.length === 0) {
+        // Also check ports without script name (general project ports)
+        const allPorts = db.getProjectPorts(project.id);
+        for (const portInfo of allPorts) {
+            const inUse = await (0, port_utils_1.detectPortInUse)(portInfo.port);
+            if (inUse) {
+                return await handlePortConflict(portInfo.port, project.name, force);
+            }
+        }
+        return true;
+    }
+    for (const portInfo of ports) {
+        const inUse = await (0, port_utils_1.detectPortInUse)(portInfo.port);
+        if (inUse) {
+            return await handlePortConflict(portInfo.port, project.name, force);
+        }
+    }
+    return true;
+}
+/**
+ * Execute a script in a project directory
+ */
+function runScript(projectPath, scriptName, args = [], force = false) {
+    return new Promise(async (resolve, reject) => {
+        const projectScripts = getProjectScripts(projectPath);
+        const script = projectScripts.scripts.get(scriptName);
+        if (!script) {
+            reject(new Error(`Script "${scriptName}" not found in project`));
+            return;
+        }
+        // Proactive port checking
+        const canProceed = await checkPortsBeforeExecution(projectPath, scriptName, force);
+        if (!canProceed) {
+            reject(new Error('Port conflict not resolved'));
+            return;
+        }
+        let command;
+        let commandArgs;
+        switch (script.runner) {
+            case 'npm':
+                command = 'npm';
+                commandArgs = ['run', scriptName, ...args];
+                break;
+            case 'yarn':
+                command = 'yarn';
+                commandArgs = [scriptName, ...args];
+                break;
+            case 'pnpm':
+                command = 'pnpm';
+                commandArgs = ['run', scriptName, ...args];
+                break;
+            case 'python':
+                command = 'python';
+                commandArgs = ['-m', ...script.command.split(' ').slice(1), ...args];
+                break;
+            case 'poetry':
+                command = 'poetry';
+                // For poetry, the command is already the module path, use 'run' to execute it
+                const modulePath = script.command.split(' ').slice(1).join(' ');
+                commandArgs = ['run', 'python', '-m', modulePath, ...args];
+                break;
+            case 'cargo':
+                command = 'cargo';
+                commandArgs = scriptName === 'run' ? ['run', ...args] : [scriptName, ...args];
+                break;
+            case 'go':
+                command = 'go';
+                commandArgs = script.command.split(' ').slice(1);
+                if (scriptName === 'run' && args.length > 0) {
+                    commandArgs = ['run', ...args];
+                }
+                else {
+                    commandArgs = [...commandArgs, ...args];
+                }
+                break;
+            case 'make':
+                command = 'make';
+                commandArgs = [scriptName, ...args];
+                break;
+            default:
+                // Fallback: try to run the command directly
+                const parts = script.command.split(' ');
+                command = parts[0];
+                commandArgs = [...parts.slice(1), ...args];
+                break;
+        }
+        console.log(`Running: ${command} ${commandArgs.join(' ')}`);
+        console.log(`In directory: ${projectPath}\n`);
+        // Capture stderr for reactive port conflict detection
+        let stderrOutput = '';
+        let stdoutOutput = '';
+        const child = (0, child_process_1.spawn)(command, commandArgs, {
+            cwd: projectPath,
+            stdio: ['inherit', 'pipe', 'pipe'],
+            shell: process.platform === 'win32',
+        });
+        // Capture output for error analysis
+        if (child.stdout) {
+            child.stdout.on('data', (data) => {
+                stdoutOutput += data.toString();
+                process.stdout.write(data);
+            });
+        }
+        if (child.stderr) {
+            child.stderr.on('data', (data) => {
+                stderrOutput += data.toString();
+                process.stderr.write(data);
+            });
+        }
+        child.on('close', async (code) => {
+            if (code === 0) {
+                resolve(0);
+            }
+            else {
+                // Reactive port conflict detection
+                const errorOutput = stderrOutput + stdoutOutput;
+                const port = (0, port_utils_1.extractPortFromError)(errorOutput);
+                if (port) {
+                    const db = (0, core_1.getDatabaseManager)();
+                    const project = db.getProjectByPath(projectPath);
+                    const projectName = project?.name || 'project';
+                    const resolved = await handlePortConflict(port, projectName, force);
+                    if (resolved) {
+                        // Retry script execution
+                        try {
+                            const retryResult = await runScript(projectPath, scriptName, args, force);
+                            resolve(retryResult);
+                        }
+                        catch (retryError) {
+                            reject(retryError);
+                        }
+                    }
+                    else {
+                        reject(new Error(`Script exited with code ${code} (port ${port} conflict)`));
+                    }
+                }
+                else {
+                    reject(new Error(`Script exited with code ${code}`));
+                }
+            }
+        });
+        child.on('error', (error) => {
+            reject(new Error(`Failed to execute script: ${error.message}`));
+        });
+    });
+}
+/**
+ * Get the path to the processes file
+ */
+function getProcessesFilePath() {
+    const dataDir = path.join(os.homedir(), '.projax');
+    if (!fs.existsSync(dataDir)) {
+        fs.mkdirSync(dataDir, { recursive: true });
+    }
+    return path.join(dataDir, 'processes.json');
+}
+/**
+ * Load running processes from disk
+ */
+function loadProcesses() {
+    const filePath = getProcessesFilePath();
+    if (!fs.existsSync(filePath)) {
+        return [];
+    }
+    try {
+        const content = fs.readFileSync(filePath, 'utf-8');
+        return JSON.parse(content);
+    }
+    catch (error) {
+        return [];
+    }
+}
+/**
+ * Save running processes to disk
+ */
+function saveProcesses(processes) {
+    const filePath = getProcessesFilePath();
+    fs.writeFileSync(filePath, JSON.stringify(processes, null, 2));
+}
+/**
+ * Add a process to the tracking file
+ */
+function addProcess(process) {
+    const processes = loadProcesses();
+    processes.push(process);
+    saveProcesses(processes);
+}
+/**
+ * Remove a process from tracking by PID
+ */
+function removeProcess(pid) {
+    const processes = loadProcesses();
+    const filtered = processes.filter(p => p.pid !== pid);
+    saveProcesses(filtered);
+}
+/**
+ * Get all running processes for a project
+ */
+function getProjectProcesses(projectPath) {
+    const processes = loadProcesses();
+    return processes.filter(p => p.projectPath === projectPath);
+}
+/**
+ * Execute a script in the background (minimal logging)
+ */
+function runScriptInBackground(projectPath, projectName, scriptName, args = [], force = false) {
+    return new Promise(async (resolve, reject) => {
+        const projectScripts = getProjectScripts(projectPath);
+        const script = projectScripts.scripts.get(scriptName);
+        if (!script) {
+            reject(new Error(`Script "${scriptName}" not found in project`));
+            return;
+        }
+        // Proactive port checking
+        const canProceed = await checkPortsBeforeExecution(projectPath, scriptName, force);
+        if (!canProceed) {
+            reject(new Error('Port conflict not resolved'));
+            return;
+        }
+        let command;
+        let commandArgs;
+        switch (script.runner) {
+            case 'npm':
+                command = 'npm';
+                commandArgs = ['run', scriptName, ...args];
+                break;
+            case 'yarn':
+                command = 'yarn';
+                commandArgs = [scriptName, ...args];
+                break;
+            case 'pnpm':
+                command = 'pnpm';
+                commandArgs = ['run', scriptName, ...args];
+                break;
+            case 'python':
+                command = 'python';
+                commandArgs = ['-m', ...script.command.split(' ').slice(1), ...args];
+                break;
+            case 'poetry':
+                command = 'poetry';
+                const modulePath = script.command.split(' ').slice(1).join(' ');
+                commandArgs = ['run', 'python', '-m', modulePath, ...args];
+                break;
+            case 'cargo':
+                command = 'cargo';
+                commandArgs = scriptName === 'run' ? ['run', ...args] : [scriptName, ...args];
+                break;
+            case 'go':
+                command = 'go';
+                commandArgs = script.command.split(' ').slice(1);
+                if (scriptName === 'run' && args.length > 0) {
+                    commandArgs = ['run', ...args];
+                }
+                else {
+                    commandArgs = [...commandArgs, ...args];
+                }
+                break;
+            case 'make':
+                command = 'make';
+                commandArgs = [scriptName, ...args];
+                break;
+            default:
+                const parts = script.command.split(' ');
+                command = parts[0];
+                commandArgs = [...parts.slice(1), ...args];
+                break;
+        }
+        // Create log file for the process
+        const dataDir = path.join(os.homedir(), '.projax');
+        const logsDir = path.join(dataDir, 'logs');
+        if (!fs.existsSync(logsDir)) {
+            fs.mkdirSync(logsDir, { recursive: true });
+        }
+        const logFile = path.join(logsDir, `process-${Date.now()}-${scriptName}.log`);
+        // Create write stream for log file (keep reference to prevent GC)
+        const logStream = fs.createWriteStream(logFile, { flags: 'a' });
+        // Spawn process in detached mode with output redirected to log file
+        const child = (0, child_process_1.spawn)(command, commandArgs, {
+            cwd: projectPath,
+            stdio: ['ignore', logStream, logStream], // Redirect stdout and stderr to log file
+            detached: true,
+            shell: process.platform === 'win32',
+        });
+        // Don't close the stream - let it stay open for the child process
+        // The stream will be closed when the child process exits
+        // Store process info
+        const processInfo = {
+            pid: child.pid,
+            projectPath,
+            projectName,
+            scriptName,
+            command: `${command} ${commandArgs.join(' ')}`,
+            startedAt: Date.now(),
+            logFile,
+        };
+        addProcess(processInfo);
+        // Unref so parent can exit and process runs independently
+        child.unref();
+        // Show minimal output
+        console.log(`✓ Started "${projectName}" (${scriptName}) in background [PID: ${child.pid}]`);
+        console.log(`  Logs: ${logFile}`);
+        console.log(`  Command: ${command} ${commandArgs.join(' ')}\n`);
+        // For background processes, we can't easily do reactive detection
+        // But we can check the log file after a short delay for port conflicts
+        setTimeout(async () => {
+            try {
+                // Wait a bit for process to start and potentially fail
+                await new Promise(resolve => setTimeout(resolve, 2000));
+                if (fs.existsSync(logFile)) {
+                    const logContent = fs.readFileSync(logFile, 'utf-8');
+                    const port = (0, port_utils_1.extractPortFromError)(logContent);
+                    if (port) {
+                        console.error(`\n⚠️  Port conflict detected in background process: port ${port} is in use`);
+                        console.error(`   Check log file: ${logFile}`);
+                        console.error(`   Use: prx <project> <script> --force to auto-resolve port conflicts\n`);
+                    }
+                }
+            }
+            catch {
+                // Ignore errors checking log file
+            }
+        }, 3000);
+        // Resolve immediately since process is running in background
+        resolve(0);
+    });
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};