projax 1.3.8 → 1.3.10

package/dist/electron/script-runner.js

@@ -40,6 +40,7 @@ exports.loadProcesses = loadProcesses;
 exports.removeProcess = removeProcess;
 exports.getProjectProcesses = getProjectProcesses;
 exports.getRunningProcesses = getRunningProcesses;
+exports.getRunningProcessesClean = getRunningProcessesClean;
 exports.stopScript = stopScript;
 exports.stopScriptByPort = stopScriptByPort;
 exports.stopProjectProcesses = stopProjectProcesses;
@@ -532,11 +533,61 @@ function getProjectProcesses(projectPath) {
     return processes.filter(p => p.projectPath === projectPath);
 }
 /**
- * Get all running processes
+ * Check if a process is still running
+ */
+async function isProcessRunning(pid) {
+    try {
+        if (os.platform() === 'win32') {
+            const { exec } = require('child_process');
+            const { promisify } = require('util');
+            const execAsync = promisify(exec);
+            const { stdout } = await execAsync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`);
+            return stdout.includes(`"${pid}"`);
+        }
+        else {
+            // On Unix-like systems, kill with signal 0 checks if process exists
+            try {
+                process.kill(pid, 0);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Clean up dead processes from tracking
+ */
+async function cleanupDeadProcesses() {
+    const processes = loadProcesses();
+    const aliveProcesses = [];
+    for (const proc of processes) {
+        const isAlive = await isProcessRunning(proc.pid);
+        if (isAlive) {
+            aliveProcesses.push(proc);
+        }
+    }
+    if (aliveProcesses.length !== processes.length) {
+        saveProcesses(aliveProcesses);
+    }
+}
+/**
+ * Get all running processes (synchronous version that returns potentially stale data)
  */
 function getRunningProcesses() {
     return loadProcesses();
 }
+/**
+ * Get all running processes with cleanup (async version)
+ */
+async function getRunningProcessesClean() {
+    await cleanupDeadProcesses();
+    return loadProcesses();
+}
 /**
  * Extract URLs from text output
  */
@@ -744,35 +795,43 @@ function runScriptInBackground(projectPath, projectName, scriptName, args = [],
             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' });
+        // Open log file with file descriptors that can be inherited by child process
+        const logFd = fs.openSync(logFile, 'a');
         // Spawn process in detached mode with output redirected to log file
         let child;
         try {
             child = (0, child_process_1.spawn)(command, commandArgs, {
                 cwd: projectPath,
-                stdio: ['ignore', logStream, logStream], // Redirect stdout and stderr to log file
+                stdio: ['ignore', logFd, logFd], // Redirect stdout and stderr to log file descriptor
                 detached: true,
                 shell: process.platform === 'win32',
             });
         }
         catch (spawnError) {
-            logStream.end();
+            fs.closeSync(logFd);
             reject(new Error(`Failed to spawn process: ${spawnError instanceof Error ? spawnError.message : String(spawnError)}`));
             return;
         }
         if (!child.pid) {
-            logStream.end();
+            fs.closeSync(logFd);
             reject(new Error('Failed to start process: no PID assigned'));
             return;
         }
         // Handle spawn errors
         child.on('error', (error) => {
-            logStream.end();
+            fs.closeSync(logFd);
             reject(new Error(`Process spawn error: ${error.message}`));
         });
-        // Don't close the stream - let it stay open for the child process
-        // The stream will be closed when the child process exits
+        // Close the file descriptor in parent process after a short delay
+        // The child process will have its own copy
+        setTimeout(() => {
+            try {
+                fs.closeSync(logFd);
+            }
+            catch {
+                // Already closed or error, ignore
+            }
+        }, 1000);
         // Store process info
         const processInfo = {
             pid: child.pid,
@@ -784,6 +843,18 @@ function runScriptInBackground(projectPath, projectName, scriptName, args = [],
             logFile,
         };
         addProcess(processInfo);
+        // Listen for process exit to clean up tracking
+        child.on('exit', (code, signal) => {
+            // Remove from tracking when process exits
+            removeProcess(child.pid);
+            // Log exit information
+            if (code !== null) {
+                fs.appendFileSync(logFile, `\n\n[Process exited with code ${code}]\n`);
+            }
+            else if (signal !== null) {
+                fs.appendFileSync(logFile, `\n\n[Process killed by signal ${signal}]\n`);
+            }
+        });
         // Unref so parent can exit and process runs independently
         child.unref();
         // Show minimal output

package/dist/index.js

@@ -37,6 +37,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
+const os = __importStar(require("os"));
 const http = __importStar(require("http"));
 const core_bridge_1 = require("./core-bridge");
 const script_runner_1 = require("./script-runner");
@@ -724,7 +725,7 @@ program
 // CD command - change to project directory (outputs shell command for eval)
 program
     .command('cd')
-    .description('Change to a project directory (use with: eval $(prx cd <project>))')
+    .description('Change to a project directory')
     .argument('[project]', 'Project ID or name (leave empty for interactive selection)')
     .action(async (projectIdentifier) => {
     try {
@@ -762,17 +763,117 @@ program
             console.error('Error: No project selected');
             process.exit(1);
         }
-        // Output a shell command that can be evaluated to change directory
-        // This allows: eval $(prx cd <project>)
-        // Or create a shell function: prxcd() { eval $(prx cd "$@"); }
+        // Output a shell command that changes directory
+        // To use: eval "$(prx cd <project>)"
         const escapedPath = project.path.replace(/'/g, "'\\''");
-        console.log(`cd '${escapedPath}'`);
+        console.log(`cd '${escapedPath}' && echo "Changed to: ${project.name}"`);
     }
     catch (error) {
         console.error('Error changing to project directory:', error instanceof Error ? error.message : error);
         process.exit(1);
     }
 });
+// Run script command
+program
+    .command('run <project> <script>')
+    .description('Run a script from a project')
+    .option('-b, --background', 'Run script in background')
+    .option('-f, --force', 'Force run (kill conflicting processes on ports)')
+    .action(async (projectIdentifier, scriptName, options) => {
+    try {
+        const projects = (0, core_bridge_1.getAllProjects)();
+        // Find project by ID or name
+        let project;
+        const numericId = parseInt(projectIdentifier, 10);
+        if (!isNaN(numericId)) {
+            project = projects.find((p) => p.id === numericId);
+        }
+        if (!project) {
+            project = projects.find((p) => p.name === projectIdentifier);
+        }
+        if (!project) {
+            console.error(`Error: Project not found: ${projectIdentifier}`);
+            process.exit(1);
+        }
+        const projectScripts = (0, script_runner_1.getProjectScripts)(project.path);
+        if (!projectScripts.scripts.has(scriptName)) {
+            console.error(`Error: Script "${scriptName}" not found in project "${project.name}"`);
+            console.error(`\nAvailable scripts:`);
+            projectScripts.scripts.forEach((script) => {
+                console.error(`  ${script.name}`);
+            });
+            process.exit(1);
+        }
+        if (options.background) {
+            await (0, script_runner_1.runScriptInBackground)(project.path, project.name, scriptName, [], options.force || false);
+        }
+        else {
+            await (0, script_runner_1.runScript)(project.path, scriptName, [], options.force || false);
+        }
+    }
+    catch (error) {
+        console.error('Error running script:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// List running processes command
+program
+    .command('ps')
+    .description('List running background processes')
+    .action(async () => {
+    try {
+        const { getRunningProcessesClean } = await Promise.resolve().then(() => __importStar(require('./script-runner')));
+        const processes = await getRunningProcessesClean();
+        if (processes.length === 0) {
+            console.log('No running background processes.');
+            return;
+        }
+        console.log(`\nRunning processes (${processes.length}):\n`);
+        for (const proc of processes) {
+            const uptime = Math.floor((Date.now() - proc.startedAt) / 1000);
+            const minutes = Math.floor(uptime / 60);
+            const seconds = uptime % 60;
+            const uptimeStr = minutes > 0 ? `${minutes}m ${seconds}s` : `${seconds}s`;
+            console.log(`  PID ${proc.pid}: ${proc.projectName} (${proc.scriptName}) - ${uptimeStr}`);
+            console.log(`  Command: ${proc.command}`);
+            console.log(`  Logs: ${proc.logFile}`);
+            if (proc.detectedUrls && proc.detectedUrls.length > 0) {
+                console.log(`  URLs: ${proc.detectedUrls.join(', ')}`);
+            }
+            console.log('');
+        }
+    }
+    catch (error) {
+        console.error('Error listing processes:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
+// Stop process command
+program
+    .command('stop <pid>')
+    .description('Stop a running background process')
+    .action(async (pidStr) => {
+    try {
+        const pid = parseInt(pidStr, 10);
+        if (isNaN(pid)) {
+            console.error('Error: Invalid PID');
+            process.exit(1);
+        }
+        const { stopScript } = await Promise.resolve().then(() => __importStar(require('./script-runner')));
+        const success = await stopScript(pid);
+        if (success) {
+            console.log(`✓ Stopped process ${pid}`);
+        }
+        else {
+            console.error(`Failed to stop process ${pid}`);
+            process.exit(1);
+        }
+    }
+    catch (error) {
+        console.error('Error stopping process:', error instanceof Error ? error.message : error);
+        process.exit(1);
+    }
+});
 // Start Desktop UI command
 program
     .command('web')
@@ -782,6 +883,25 @@ program
     .option('--dev', 'Start in development mode (with hot reload)')
     .action(async (options) => {
     try {
+        // Clear Electron cache to prevent stale module issues
+        if (os.platform() === 'darwin') {
+            const cacheDirs = [
+                path.join(os.homedir(), 'Library', 'Application Support', 'Electron', 'Cache'),
+                path.join(os.homedir(), 'Library', 'Application Support', 'Electron', 'Code Cache'),
+                path.join(os.homedir(), 'Library', 'Application Support', 'Electron', 'GPUCache'),
+                path.join(os.homedir(), 'Library', 'Caches', 'Electron'),
+            ];
+            for (const dir of cacheDirs) {
+                try {
+                    if (fs.existsSync(dir)) {
+                        fs.rmSync(dir, { recursive: true, force: true });
+                    }
+                }
+                catch (error) {
+                    // Ignore cache clear errors
+                }
+            }
+        }
         // Ensure API server is running before starting Desktop app
         await ensureAPIServerRunning(false);
         // Check for bundled Desktop app first (in dist/desktop when installed globally)
@@ -1031,7 +1151,7 @@ program
 // Check if first argument is not a known command
 (async () => {
     const args = process.argv.slice(2);
-    const knownCommands = ['prxi', 'i', 'add', 'list', 'scan', 'remove', 'rn', 'rename', 'cd', 'pwd', 'web', 'desktop', 'ui', 'scripts', 'scan-ports', 'api', '--help', '-h', '--version', '-V'];
+    const knownCommands = ['prxi', 'i', 'add', 'list', 'scan', 'remove', 'rn', 'rename', 'cd', 'pwd', 'run', 'ps', 'stop', 'web', 'desktop', 'ui', 'scripts', 'scan-ports', 'api', '--help', '-h', '--version', '-V'];
     // If we have at least 1 argument and first is not a known command, treat as project identifier
     if (args.length >= 1 && !knownCommands.includes(args[0])) {
         const projectIdentifier = args[0];

package/dist/script-runner.d.ts

@@ -44,9 +44,13 @@ export declare function removeProcess(pid: number): void;
  */
 export declare function getProjectProcesses(projectPath: string): BackgroundProcess[];
 /**
- * Get all running processes
+ * Get all running processes (synchronous version that returns potentially stale data)
  */
 export declare function getRunningProcesses(): BackgroundProcess[];
+/**
+ * Get all running processes with cleanup (async version)
+ */
+export declare function getRunningProcessesClean(): Promise<BackgroundProcess[]>;
 /**
  * Stop a script by PID
  */

package/dist/script-runner.js

@@ -40,6 +40,7 @@ exports.loadProcesses = loadProcesses;
 exports.removeProcess = removeProcess;
 exports.getProjectProcesses = getProjectProcesses;
 exports.getRunningProcesses = getRunningProcesses;
+exports.getRunningProcessesClean = getRunningProcessesClean;
 exports.stopScript = stopScript;
 exports.stopScriptByPort = stopScriptByPort;
 exports.stopProjectProcesses = stopProjectProcesses;
@@ -532,11 +533,61 @@ function getProjectProcesses(projectPath) {
     return processes.filter(p => p.projectPath === projectPath);
 }
 /**
- * Get all running processes
+ * Check if a process is still running
+ */
+async function isProcessRunning(pid) {
+    try {
+        if (os.platform() === 'win32') {
+            const { exec } = require('child_process');
+            const { promisify } = require('util');
+            const execAsync = promisify(exec);
+            const { stdout } = await execAsync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`);
+            return stdout.includes(`"${pid}"`);
+        }
+        else {
+            // On Unix-like systems, kill with signal 0 checks if process exists
+            try {
+                process.kill(pid, 0);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        }
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Clean up dead processes from tracking
+ */
+async function cleanupDeadProcesses() {
+    const processes = loadProcesses();
+    const aliveProcesses = [];
+    for (const proc of processes) {
+        const isAlive = await isProcessRunning(proc.pid);
+        if (isAlive) {
+            aliveProcesses.push(proc);
+        }
+    }
+    if (aliveProcesses.length !== processes.length) {
+        saveProcesses(aliveProcesses);
+    }
+}
+/**
+ * Get all running processes (synchronous version that returns potentially stale data)
  */
 function getRunningProcesses() {
     return loadProcesses();
 }
+/**
+ * Get all running processes with cleanup (async version)
+ */
+async function getRunningProcessesClean() {
+    await cleanupDeadProcesses();
+    return loadProcesses();
+}
 /**
  * Extract URLs from text output
  */
@@ -744,35 +795,43 @@ function runScriptInBackground(projectPath, projectName, scriptName, args = [],
             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' });
+        // Open log file with file descriptors that can be inherited by child process
+        const logFd = fs.openSync(logFile, 'a');
         // Spawn process in detached mode with output redirected to log file
         let child;
         try {
             child = (0, child_process_1.spawn)(command, commandArgs, {
                 cwd: projectPath,
-                stdio: ['ignore', logStream, logStream], // Redirect stdout and stderr to log file
+                stdio: ['ignore', logFd, logFd], // Redirect stdout and stderr to log file descriptor
                 detached: true,
                 shell: process.platform === 'win32',
             });
         }
         catch (spawnError) {
-            logStream.end();
+            fs.closeSync(logFd);
             reject(new Error(`Failed to spawn process: ${spawnError instanceof Error ? spawnError.message : String(spawnError)}`));
             return;
         }
         if (!child.pid) {
-            logStream.end();
+            fs.closeSync(logFd);
             reject(new Error('Failed to start process: no PID assigned'));
             return;
         }
         // Handle spawn errors
         child.on('error', (error) => {
-            logStream.end();
+            fs.closeSync(logFd);
             reject(new Error(`Process spawn error: ${error.message}`));
         });
-        // Don't close the stream - let it stay open for the child process
-        // The stream will be closed when the child process exits
+        // Close the file descriptor in parent process after a short delay
+        // The child process will have its own copy
+        setTimeout(() => {
+            try {
+                fs.closeSync(logFd);
+            }
+            catch {
+                // Already closed or error, ignore
+            }
+        }, 1000);
         // Store process info
         const processInfo = {
             pid: child.pid,
@@ -784,6 +843,18 @@ function runScriptInBackground(projectPath, projectName, scriptName, args = [],
             logFile,
         };
         addProcess(processInfo);
+        // Listen for process exit to clean up tracking
+        child.on('exit', (code, signal) => {
+            // Remove from tracking when process exits
+            removeProcess(child.pid);
+            // Log exit information
+            if (code !== null) {
+                fs.appendFileSync(logFile, `\n\n[Process exited with code ${code}]\n`);
+            }
+            else if (signal !== null) {
+                fs.appendFileSync(logFile, `\n\n[Process killed by signal ${signal}]\n`);
+            }
+        });
         // Unref so parent can exit and process runs independently
         child.unref();
         // Show minimal output

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "projax",
-  "version": "1.3.8",
+  "version": "1.3.10",
   "description": "CLI tool for managing local development projects",
   "main": "dist/index.js",
   "bin": {