projax 0.1.29 → 1.0.1

package/dist/electron/script-runner.js

@@ -36,7 +36,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectProjectType = detectProjectType;
 exports.getProjectScripts = getProjectScripts;
 exports.runScript = runScript;
+exports.loadProcesses = loadProcesses;
+exports.removeProcess = removeProcess;
 exports.getProjectProcesses = getProjectProcesses;
+exports.getRunningProcesses = getRunningProcesses;
+exports.stopScript = stopScript;
+exports.stopScriptByPort = stopScriptByPort;
+exports.stopProjectProcesses = stopProjectProcesses;
 exports.runScriptInBackground = runScriptInBackground;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -525,6 +531,147 @@ function getProjectProcesses(projectPath) {
     const processes = loadProcesses();
     return processes.filter(p => p.projectPath === projectPath);
 }
+/**
+ * Get all running processes
+ */
+function getRunningProcesses() {
+    return loadProcesses();
+}
+/**
+ * Extract URLs from text output
+ */
+function extractUrlsFromOutput(output) {
+    const urls = [];
+    const urlPatterns = [
+        /(?:Local|Network):\s*(https?:\/\/[^\s]+)/gi,
+        /(?:https?:\/\/localhost:\d+)/gi,
+        /(?:https?:\/\/127\.0\.0\.1:\d+)/gi,
+        /(?:https?:\/\/0\.0\.0\.0:\d+)/gi,
+        /(?:https?:\/\/[^\s:]+:\d+)/gi,
+    ];
+    for (const pattern of urlPatterns) {
+        const matches = output.matchAll(pattern);
+        for (const match of matches) {
+            const url = match[0] || match[1];
+            if (url && !urls.includes(url)) {
+                urls.push(url);
+            }
+        }
+    }
+    return urls;
+}
+/**
+ * Update process with detected URLs
+ */
+function updateProcessUrls(pid, urls) {
+    const processes = loadProcesses();
+    const process = processes.find(p => p.pid === pid);
+    if (process) {
+        process.detectedUrls = urls;
+        saveProcesses(processes);
+    }
+}
+/**
+ * Stop a script by PID
+ */
+async function stopScript(pid) {
+    try {
+        const processes = loadProcesses();
+        const processInfo = processes.find(p => p.pid === pid);
+        if (!processInfo) {
+            return false;
+        }
+        // Check if process is still running before trying to kill it
+        let processExists = false;
+        try {
+            if (os.platform() === 'win32') {
+                const { exec } = require('child_process');
+                const { promisify } = require('util');
+                const execAsync = promisify(exec);
+                await execAsync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`);
+                processExists = true;
+            }
+            else {
+                const { exec } = require('child_process');
+                const { promisify } = require('util');
+                const execAsync = promisify(exec);
+                await execAsync(`ps -p ${pid} -o pid=`);
+                processExists = true;
+            }
+        }
+        catch {
+            // Process doesn't exist anymore
+            processExists = false;
+        }
+        // Try to kill the process (cross-platform)
+        if (processExists) {
+            try {
+                if (os.platform() === 'win32') {
+                    const { exec } = require('child_process');
+                    const { promisify } = require('util');
+                    const execAsync = promisify(exec);
+                    await execAsync(`taskkill /F /PID ${pid}`);
+                }
+                else {
+                    const { exec } = require('child_process');
+                    const { promisify } = require('util');
+                    const execAsync = promisify(exec);
+                    await execAsync(`kill -9 ${pid}`);
+                }
+            }
+            catch (error) {
+                // Process may have already exited
+                console.error(`Error killing process ${pid}:`, error);
+            }
+        }
+        // Remove from tracking regardless of whether kill succeeded
+        removeProcess(pid);
+        return true;
+    }
+    catch (error) {
+        console.error(`Error stopping script ${pid}:`, error);
+        return false;
+    }
+}
+/**
+ * Stop a script by port (finds process using port and kills it)
+ */
+async function stopScriptByPort(port) {
+    try {
+        const processInfo = await (0, port_utils_1.getProcessOnPort)(port);
+        if (!processInfo) {
+            return false;
+        }
+        // Check if this is a tracked process
+        const processes = loadProcesses();
+        const trackedProcess = processes.find(p => p.pid === processInfo.pid);
+        if (trackedProcess) {
+            // Use the tracked process removal
+            return await stopScript(processInfo.pid);
+        }
+        else {
+            // Kill the process directly
+            const killed = await (0, port_utils_1.killProcessOnPort)(port);
+            return killed;
+        }
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Stop all processes for a project
+ */
+async function stopProjectProcesses(projectPath) {
+    const processes = getProjectProcesses(projectPath);
+    let stopped = 0;
+    for (const process of processes) {
+        if (await stopScript(process.pid)) {
+            stopped++;
+        }
+    }
+    return stopped;
+}
 /**
  * Execute a script in the background (minimal logging)
  */
@@ -626,25 +773,53 @@ function runScriptInBackground(projectPath, projectName, scriptName, args = [],
         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
+        // But we can check the log file after a short delay for port conflicts and URLs
         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');
+                    // Check for port conflicts
                     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`);
                     }
+                    // Extract URLs from output
+                    const urls = extractUrlsFromOutput(logContent);
+                    if (urls.length > 0) {
+                        updateProcessUrls(child.pid, urls);
+                    }
                 }
             }
             catch {
                 // Ignore errors checking log file
             }
         }, 3000);
+        // Also check for URLs from detected ports
+        setTimeout(async () => {
+            try {
+                const db = (0, core_1.getDatabaseManager)();
+                const project = db.getProjectByPath(projectPath);
+                if (project) {
+                    const ports = db.getProjectPorts(project.id);
+                    const urls = [];
+                    for (const portInfo of ports) {
+                        if (portInfo.script_name === scriptName) {
+                            urls.push(`http://localhost:${portInfo.port}`);
+                        }
+                    }
+                    if (urls.length > 0) {
+                        updateProcessUrls(child.pid, urls);
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }, 5000);
         // Resolve immediately since process is running in background
         resolve(0);
     });

package/dist/index.js

@@ -42,11 +42,29 @@ const script_runner_1 = require("./script-runner");
 const port_scanner_1 = require("./port-scanner");
 // Read version from package.json
 const packageJson = require('../package.json');
+// ASCII logo for projax
+function displayLogo() {
+    return `
+╔═══════════════════════════════════════╗
+║                                       ║
+║    ██████╗ ██████╗  ██████╗      ██╗  ║
+║    ██╔══██╗██╔══██╗██╔═══██╗     ██║  ║
+║    ██████╔╝██████╔╝██║   ██║     ██║  ║
+║    ██╔═══╝ ██╔══██╗██║   ██║██   ██║  ║
+║    ██║     ██║  ██║╚██████╔╝╚█████╔╝  ║
+║    ╚═╝     ╚═╝  ╚═╝ ╚═════╝  ╚════╝   ║
+║                                       ║
+║         Project Management CLI        ║
+║                                       ║
+╚═══════════════════════════════════════╝
+`;
+}
 const program = new commander_1.Command();
 program
     .name('prx')
     .description('Project management dashboard CLI')
-    .version(packageJson.version);
+    .version(packageJson.version)
+    .addHelpText('beforeAll', displayLogo());
 // Add project command
 program
     .command('add')
@@ -832,7 +850,7 @@ program
 // Check if first argument is not a known command
 (async () => {
     const args = process.argv.slice(2);
-    const knownCommands = ['add', 'list', 'scan', 'remove', 'rn', 'rename', 'cd', 'pwd', 'web', 'scripts', 'scan-ports', '--help', '-h', '--version', '-v'];
+    const knownCommands = ['add', 'list', 'scan', 'remove', 'rn', 'rename', 'cd', 'pwd', 'web', 'scripts', 'scan-ports', '--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];
@@ -967,5 +985,6 @@ program
         }
     }
     // If we get here, proceed with normal command parsing
+    // Don't show logo twice - it's already in addHelpText
     program.parse();
 })();

package/dist/script-runner.d.ts

@@ -29,11 +29,36 @@ export interface BackgroundProcess {
     command: string;
     startedAt: number;
     logFile: string;
+    detectedUrls?: string[];
 }
+/**
+ * Load running processes from disk
+ */
+export declare function loadProcesses(): BackgroundProcess[];
+/**
+ * Remove a process from tracking by PID
+ */
+export declare function removeProcess(pid: number): void;
 /**
  * Get all running processes for a project
  */
 export declare function getProjectProcesses(projectPath: string): BackgroundProcess[];
+/**
+ * Get all running processes
+ */
+export declare function getRunningProcesses(): BackgroundProcess[];
+/**
+ * Stop a script by PID
+ */
+export declare function stopScript(pid: number): Promise<boolean>;
+/**
+ * Stop a script by port (finds process using port and kills it)
+ */
+export declare function stopScriptByPort(port: number): Promise<boolean>;
+/**
+ * Stop all processes for a project
+ */
+export declare function stopProjectProcesses(projectPath: string): Promise<number>;
 /**
  * Execute a script in the background (minimal logging)
  */

package/dist/script-runner.js

@@ -36,7 +36,13 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.detectProjectType = detectProjectType;
 exports.getProjectScripts = getProjectScripts;
 exports.runScript = runScript;
+exports.loadProcesses = loadProcesses;
+exports.removeProcess = removeProcess;
 exports.getProjectProcesses = getProjectProcesses;
+exports.getRunningProcesses = getRunningProcesses;
+exports.stopScript = stopScript;
+exports.stopScriptByPort = stopScriptByPort;
+exports.stopProjectProcesses = stopProjectProcesses;
 exports.runScriptInBackground = runScriptInBackground;
 const fs = __importStar(require("fs"));
 const path = __importStar(require("path"));
@@ -525,6 +531,147 @@ function getProjectProcesses(projectPath) {
     const processes = loadProcesses();
     return processes.filter(p => p.projectPath === projectPath);
 }
+/**
+ * Get all running processes
+ */
+function getRunningProcesses() {
+    return loadProcesses();
+}
+/**
+ * Extract URLs from text output
+ */
+function extractUrlsFromOutput(output) {
+    const urls = [];
+    const urlPatterns = [
+        /(?:Local|Network):\s*(https?:\/\/[^\s]+)/gi,
+        /(?:https?:\/\/localhost:\d+)/gi,
+        /(?:https?:\/\/127\.0\.0\.1:\d+)/gi,
+        /(?:https?:\/\/0\.0\.0\.0:\d+)/gi,
+        /(?:https?:\/\/[^\s:]+:\d+)/gi,
+    ];
+    for (const pattern of urlPatterns) {
+        const matches = output.matchAll(pattern);
+        for (const match of matches) {
+            const url = match[0] || match[1];
+            if (url && !urls.includes(url)) {
+                urls.push(url);
+            }
+        }
+    }
+    return urls;
+}
+/**
+ * Update process with detected URLs
+ */
+function updateProcessUrls(pid, urls) {
+    const processes = loadProcesses();
+    const process = processes.find(p => p.pid === pid);
+    if (process) {
+        process.detectedUrls = urls;
+        saveProcesses(processes);
+    }
+}
+/**
+ * Stop a script by PID
+ */
+async function stopScript(pid) {
+    try {
+        const processes = loadProcesses();
+        const processInfo = processes.find(p => p.pid === pid);
+        if (!processInfo) {
+            return false;
+        }
+        // Check if process is still running before trying to kill it
+        let processExists = false;
+        try {
+            if (os.platform() === 'win32') {
+                const { exec } = require('child_process');
+                const { promisify } = require('util');
+                const execAsync = promisify(exec);
+                await execAsync(`tasklist /FI "PID eq ${pid}" /FO CSV /NH`);
+                processExists = true;
+            }
+            else {
+                const { exec } = require('child_process');
+                const { promisify } = require('util');
+                const execAsync = promisify(exec);
+                await execAsync(`ps -p ${pid} -o pid=`);
+                processExists = true;
+            }
+        }
+        catch {
+            // Process doesn't exist anymore
+            processExists = false;
+        }
+        // Try to kill the process (cross-platform)
+        if (processExists) {
+            try {
+                if (os.platform() === 'win32') {
+                    const { exec } = require('child_process');
+                    const { promisify } = require('util');
+                    const execAsync = promisify(exec);
+                    await execAsync(`taskkill /F /PID ${pid}`);
+                }
+                else {
+                    const { exec } = require('child_process');
+                    const { promisify } = require('util');
+                    const execAsync = promisify(exec);
+                    await execAsync(`kill -9 ${pid}`);
+                }
+            }
+            catch (error) {
+                // Process may have already exited
+                console.error(`Error killing process ${pid}:`, error);
+            }
+        }
+        // Remove from tracking regardless of whether kill succeeded
+        removeProcess(pid);
+        return true;
+    }
+    catch (error) {
+        console.error(`Error stopping script ${pid}:`, error);
+        return false;
+    }
+}
+/**
+ * Stop a script by port (finds process using port and kills it)
+ */
+async function stopScriptByPort(port) {
+    try {
+        const processInfo = await (0, port_utils_1.getProcessOnPort)(port);
+        if (!processInfo) {
+            return false;
+        }
+        // Check if this is a tracked process
+        const processes = loadProcesses();
+        const trackedProcess = processes.find(p => p.pid === processInfo.pid);
+        if (trackedProcess) {
+            // Use the tracked process removal
+            return await stopScript(processInfo.pid);
+        }
+        else {
+            // Kill the process directly
+            const killed = await (0, port_utils_1.killProcessOnPort)(port);
+            return killed;
+        }
+    }
+    catch (error) {
+        return false;
+    }
+}
+/**
+ * Stop all processes for a project
+ */
+async function stopProjectProcesses(projectPath) {
+    const processes = getProjectProcesses(projectPath);
+    let stopped = 0;
+    for (const process of processes) {
+        if (await stopScript(process.pid)) {
+            stopped++;
+        }
+    }
+    return stopped;
+}
 /**
  * Execute a script in the background (minimal logging)
  */
@@ -626,25 +773,53 @@ function runScriptInBackground(projectPath, projectName, scriptName, args = [],
         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
+        // But we can check the log file after a short delay for port conflicts and URLs
         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');
+                    // Check for port conflicts
                     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`);
                     }
+                    // Extract URLs from output
+                    const urls = extractUrlsFromOutput(logContent);
+                    if (urls.length > 0) {
+                        updateProcessUrls(child.pid, urls);
+                    }
                 }
             }
             catch {
                 // Ignore errors checking log file
             }
         }, 3000);
+        // Also check for URLs from detected ports
+        setTimeout(async () => {
+            try {
+                const db = (0, core_1.getDatabaseManager)();
+                const project = db.getProjectByPath(projectPath);
+                if (project) {
+                    const ports = db.getProjectPorts(project.id);
+                    const urls = [];
+                    for (const portInfo of ports) {
+                        if (portInfo.script_name === scriptName) {
+                            urls.push(`http://localhost:${portInfo.port}`);
+                        }
+                    }
+                    if (urls.length > 0) {
+                        updateProcessUrls(child.pid, urls);
+                    }
+                }
+            }
+            catch {
+                // Ignore errors
+            }
+        }, 5000);
         // Resolve immediately since process is running in background
         resolve(0);
     });

package/package.json

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