projax 1.0.2 → 1.3.0

package/dist/index.js

@@ -37,14 +37,133 @@ Object.defineProperty(exports, "__esModule", { value: true });
 const commander_1 = require("commander");
 const path = __importStar(require("path"));
 const fs = __importStar(require("fs"));
-const core_1 = require("./core");
+const http = __importStar(require("http"));
+const projax_core_1 = require("projax-core");
 const script_runner_1 = require("./script-runner");
 const port_scanner_1 = require("./port-scanner");
 // Read version from package.json
 const packageJson = require('../package.json');
+// Function to check API status
+async function checkAPIStatus() {
+    const dataDir = path.join(require('os').homedir(), '.projax');
+    const portFile = path.join(dataDir, 'api-port.txt');
+    let port = null;
+    if (fs.existsSync(portFile)) {
+        try {
+            const portStr = fs.readFileSync(portFile, 'utf-8').trim();
+            port = parseInt(portStr, 10) || null;
+        }
+        catch {
+            // Ignore
+        }
+    }
+    if (!port) {
+        // Try common ports
+        const ports = [3001, 3002, 3003, 3004, 3005];
+        for (const p of ports) {
+            try {
+                const result = await new Promise((resolve) => {
+                    const req = http.get(`http://localhost:${p}/health`, (res) => {
+                        resolve(res.statusCode === 200);
+                    });
+                    req.on('error', () => resolve(false));
+                    req.setTimeout(500, () => {
+                        req.destroy();
+                        resolve(false);
+                    });
+                });
+                if (result) {
+                    port = p;
+                    break;
+                }
+            }
+            catch {
+                // Continue
+            }
+        }
+    }
+    if (port) {
+        try {
+            const result = await new Promise((resolve) => {
+                const req = http.get(`http://localhost:${port}/health`, (res) => {
+                    resolve(res.statusCode === 200);
+                });
+                req.on('error', () => resolve(false));
+                req.setTimeout(500, () => {
+                    req.destroy();
+                    resolve(false);
+                });
+            });
+            return { running: result, port };
+        }
+        catch {
+            return { running: false, port };
+        }
+    }
+    return { running: false, port: null };
+}
+// Function to start the API server
+async function startAPIServer(silent = false) {
+    const { spawn } = require('child_process');
+    const apiPath = path.join(__dirname, '..', '..', 'api', 'dist', 'index.js');
+    if (!fs.existsSync(apiPath)) {
+        if (!silent) {
+            console.error('Error: API server not found. Please build it first: npm run build --workspace=packages/api');
+        }
+        return false;
+    }
+    if (!silent) {
+        console.log('Starting API server...');
+    }
+    try {
+        spawn('node', [apiPath], {
+            detached: true,
+            stdio: 'ignore',
+        }).unref();
+        if (!silent) {
+            console.log('✓ API server started');
+        }
+        return true;
+    }
+    catch (error) {
+        if (!silent) {
+            console.error('Error starting API server:', error instanceof Error ? error.message : error);
+        }
+        return false;
+    }
+}
+// Function to ensure API server is running (auto-start if needed)
+async function ensureAPIServerRunning(silent = true) {
+    const apiStatus = await checkAPIStatus();
+    if (apiStatus.running) {
+        // API is already running, nothing to do
+        return;
+    }
+    // API is not running, start it
+    if (!silent) {
+        console.log('Starting API server...');
+    }
+    const started = await startAPIServer(silent);
+    if (!started) {
+        // Failed to start, but don't throw - let the command continue
+        // The error message was already shown if not silent
+        return;
+    }
+    // Wait a bit for the API server to start up
+    await new Promise(resolve => setTimeout(resolve, 1000));
+    // Verify it's running
+    const verifyStatus = await checkAPIStatus();
+    if (!verifyStatus.running && !silent) {
+        console.warn('⚠️  API server may not have started successfully. Check logs if needed.');
+    }
+}
 // ASCII logo for projax - using a clearer style that shows all 6 letters
 function displayLogo() {
     return `
+  PROJAX ${packageJson.version}
+  
+  `;
+    return `
 ╔═══════════════════════════════════════════════════════╗
 ║                                                       ║
 ║     ██████╗ ██████╗  ██████╗      ██╗  ██╗ █████╗ ██╗  ║
@@ -56,6 +175,8 @@ function displayLogo() {
 ║                                                       ║
 ║              Version ${packageJson.version}              ║
 ║                                                       ║
+║      Use "prx api" to check API server status        ║
+║                                                       ║
 ╚═══════════════════════════════════════════════════════╝
 `;
 }
@@ -107,7 +228,7 @@ program
             console.error(`Error: Path is not a directory: ${resolvedPath}`);
             process.exit(1);
         }
-        const db = (0, core_1.getDatabaseManager)();
+        const db = (0, projax_core_1.getDatabaseManager)();
         const existingProject = db.getProjectByPath(resolvedPath);
         if (existingProject) {
             console.log(`Project already exists: ${existingProject.name} (ID: ${existingProject.id})`);
@@ -152,7 +273,7 @@ program
         ]);
         if (scanAnswer.scan) {
             console.log('Scanning for tests...');
-            const result = (0, core_1.scanProject)(project.id);
+            const result = (0, projax_core_1.scanProject)(project.id);
             console.log(`✓ Found ${result.testsFound} test file(s)`);
             if (result.tests.length > 0) {
                 console.log('  Test files:');
@@ -193,8 +314,8 @@ program
     .option('--ports', 'Show detailed port information per script')
     .action(async (options) => {
     try {
-        const db = (0, core_1.getDatabaseManager)();
-        const projects = (0, core_1.getAllProjects)();
+        const db = (0, projax_core_1.getDatabaseManager)();
+        const projects = (0, projax_core_1.getAllProjects)();
         if (projects.length === 0) {
             console.log('No projects tracked yet. Use "prx add" to add a project.');
             return;
@@ -301,17 +422,17 @@ program
     .argument('[project]', 'Project ID or name to scan (leave empty to scan all)')
     .action(async (projectIdentifier) => {
     try {
-        const db = (0, core_1.getDatabaseManager)();
+        const db = (0, projax_core_1.getDatabaseManager)();
         if (projectIdentifier) {
             // Find project by ID or name
-            const projects = (0, core_1.getAllProjects)();
+            const projects = (0, projax_core_1.getAllProjects)();
             const project = projects.find((p) => p.id.toString() === projectIdentifier || p.name === projectIdentifier);
             if (!project) {
                 console.error(`Error: Project not found: ${projectIdentifier}`);
                 process.exit(1);
             }
             console.log(`Scanning project: ${project.name}...`);
-            const result = (0, core_1.scanProject)(project.id);
+            const result = (0, projax_core_1.scanProject)(project.id);
             console.log(`✓ Found ${result.testsFound} test file(s)`);
             if (result.tests.length > 0) {
                 console.log('\nTest files:');
@@ -340,7 +461,7 @@ program
         else {
             // Scan all projects
             console.log('Scanning all projects...\n');
-            const results = (0, core_1.scanAllProjects)();
+            const results = (0, projax_core_1.scanAllProjects)();
             for (const result of results) {
                 console.log(`${result.project.name}: ${result.testsFound} test file(s)`);
             }
@@ -372,8 +493,8 @@ program
     .argument('<newName>', 'New name for the project')
     .action((projectIdentifier, newName) => {
     try {
-        const db = (0, core_1.getDatabaseManager)();
-        const projects = (0, core_1.getAllProjects)();
+        const db = (0, projax_core_1.getDatabaseManager)();
+        const projects = (0, projax_core_1.getAllProjects)();
         const project = projects.find(p => p.id.toString() === projectIdentifier || p.name === projectIdentifier);
         if (!project) {
             console.error(`Error: Project not found: ${projectIdentifier}`);
@@ -400,8 +521,8 @@ program
     .option('-f, --force', 'Skip confirmation')
     .action(async (projectIdentifier, options) => {
     try {
-        const db = (0, core_1.getDatabaseManager)();
-        const projects = (0, core_1.getAllProjects)();
+        const db = (0, projax_core_1.getDatabaseManager)();
+        const projects = (0, projax_core_1.getAllProjects)();
         const project = projects.find(p => p.id.toString() === projectIdentifier || p.name === projectIdentifier);
         if (!project) {
             console.error(`Error: Project not found: ${projectIdentifier}`);
@@ -422,7 +543,7 @@ program
                 return;
             }
         }
-        (0, core_1.removeProject)(project.id);
+        (0, projax_core_1.removeProject)(project.id);
         console.log(`✓ Removed project: ${project.name}`);
     }
     catch (error) {
@@ -437,7 +558,7 @@ program
     .argument('[project]', 'Project ID or name (leave empty for interactive selection)')
     .action(async (projectIdentifier) => {
     try {
-        const projects = (0, core_1.getAllProjects)();
+        const projects = (0, projax_core_1.getAllProjects)();
         if (projects.length === 0) {
             console.error('Error: No projects tracked yet. Use "prx add" to add a project.');
             process.exit(1);
@@ -501,7 +622,7 @@ program
     .argument('[project]', 'Project ID or name (leave empty for interactive selection)')
     .action(async (projectIdentifier) => {
     try {
-        const projects = (0, core_1.getAllProjects)();
+        const projects = (0, projax_core_1.getAllProjects)();
         if (projects.length === 0) {
             console.error('Error: No projects tracked yet. Use "prx add" to add a project.');
             process.exit(1);
@@ -551,7 +672,7 @@ program
     .argument('[project]', 'Project ID or name (leave empty for interactive selection)')
     .action(async (projectIdentifier) => {
     try {
-        const projects = (0, core_1.getAllProjects)();
+        const projects = (0, projax_core_1.getAllProjects)();
         if (projects.length === 0) {
             console.error('Error: No projects tracked yet. Use "prx add" to add a project.');
             process.exit(1);
@@ -596,55 +717,57 @@ program
         process.exit(1);
     }
 });
-// Start Electron UI command
+// Start Desktop UI command
 program
     .command('web')
-    .description('Start the Electron web interface')
+    .description('Start the Desktop web interface')
     .option('--dev', 'Start in development mode (with hot reload)')
     .action(async (options) => {
     try {
-        // Check for bundled Electron app first (in dist/electron when installed globally)
-        // Then check for local development (packages/cli/dist -> packages/electron)
-        const bundledElectronPath = path.join(__dirname, 'electron');
-        const bundledElectronMain = path.join(bundledElectronPath, 'main.js');
-        const localElectronPath = path.join(__dirname, '..', '..', 'electron');
-        const localElectronMain = path.join(localElectronPath, 'dist', 'main.js');
-        // Check if bundled electron exists (global install)
-        const hasBundledElectron = fs.existsSync(bundledElectronMain);
-        // Check if local electron exists (development mode)
-        const isLocalDev = fs.existsSync(localElectronPath) && fs.existsSync(path.join(localElectronPath, 'package.json'));
-        let electronPackagePath;
-        let electronMainPath;
-        if (hasBundledElectron) {
-            // Bundled Electron app (global install)
-            electronPackagePath = bundledElectronPath;
-            electronMainPath = bundledElectronMain;
+        // Ensure API server is running before starting Desktop app
+        await ensureAPIServerRunning(false);
+        // Check for bundled Desktop app first (in dist/desktop when installed globally)
+        // Then check for local development (packages/cli/dist -> packages/desktop)
+        const bundledDesktopPath = path.join(__dirname, 'desktop');
+        const bundledDesktopMain = path.join(bundledDesktopPath, 'main.js');
+        const localDesktopPath = path.join(__dirname, '..', '..', 'desktop');
+        const localDesktopMain = path.join(localDesktopPath, 'dist', 'main.js');
+        // Check if bundled desktop exists (global install)
+        const hasBundledDesktop = fs.existsSync(bundledDesktopMain);
+        // Check if local desktop exists (development mode)
+        const isLocalDev = fs.existsSync(localDesktopPath) && fs.existsSync(path.join(localDesktopPath, 'package.json'));
+        let desktopPackagePath;
+        let desktopMainPath;
+        if (hasBundledDesktop) {
+            // Bundled Desktop app (global install)
+            desktopPackagePath = bundledDesktopPath;
+            desktopMainPath = bundledDesktopMain;
         }
         else if (isLocalDev) {
             // Local development - use relative path
-            electronPackagePath = localElectronPath;
-            electronMainPath = localElectronMain;
+            desktopPackagePath = localDesktopPath;
+            desktopMainPath = localDesktopMain;
         }
         else {
-            console.error('Error: Electron app not found.');
-            console.error('\nThe Electron web interface is not available.');
+            console.error('Error: Desktop app not found.');
+            console.error('\nThe Desktop web interface is not available.');
             console.error('This may be a packaging issue. Please report this error.');
             process.exit(1);
         }
         if (options.dev) {
-            // Development mode - start Vite dev server and Electron
+            // Development mode - start Vite dev server and Desktop app
             if (!isLocalDev) {
                 console.error('Error: Development mode is only available in local development.');
-                console.error('The Electron app must be built for production use.');
+                console.error('The Desktop app must be built for production use.');
                 process.exit(1);
             }
-            console.log('Starting Electron app in development mode...');
+            console.log('Starting Desktop app in development mode...');
             console.log('Starting Vite dev server on port 7898...');
             const { spawn } = require('child_process');
             const electron = require('electron');
             // Start Vite dev server in background
             const viteProcess = spawn('npm', ['run', 'dev:renderer'], {
-                cwd: electronPackagePath,
+                cwd: desktopPackagePath,
                 stdio: 'pipe',
                 detached: false,
             });
@@ -654,8 +777,8 @@ program
                 // Wait for Vite to be ready
                 if (output.includes('Local:') || output.includes('ready')) {
                     setTimeout(() => {
-                        console.log('\nStarting Electron window...');
-                        spawn(electron, [electronMainPath], {
+                        console.log('\nStarting Desktop window...');
+                        spawn(electron, [desktopMainPath], {
                             stdio: 'inherit',
                             detached: true,
                             env: { ...process.env, NODE_ENV: 'development' },
@@ -674,44 +797,44 @@ program
             return;
         }
         // Production mode - check if built
-        if (!fs.existsSync(electronMainPath)) {
+        if (!fs.existsSync(desktopMainPath)) {
             if (!isLocalDev) {
-                console.error('Error: Electron app is not built.');
-                console.error('The @projax/electron package needs to be built.');
+                console.error('Error: Desktop app is not built.');
+                console.error('The @projax/desktop package needs to be built.');
                 console.error('Please contact the package maintainer or build it locally.');
                 process.exit(1);
             }
-            console.log('Electron app not built.');
-            console.log('Building Electron app...');
+            console.log('Desktop app not built.');
+            console.log('Building Desktop app...');
             const { execSync } = require('child_process');
             try {
-                // When in local dev, electronPackagePath points to packages/electron
+                // When in local dev, desktopPackagePath points to packages/desktop
                 // So go up two levels to get to project root
-                const projectRoot = path.join(electronPackagePath, '..', '..');
-                execSync('npm run build:electron', {
+                const projectRoot = path.join(desktopPackagePath, '..', '..');
+                execSync('npm run build:desktop', {
                     cwd: projectRoot,
                     stdio: 'inherit'
                 });
             }
             catch (error) {
                 console.error('\nBuild failed. Try running in dev mode: prx web --dev');
-                console.error('Or manually build: npm run build:electron');
+                console.error('Or manually build: npm run build:desktop');
                 process.exit(1);
             }
         }
         // Check if renderer is built
         let rendererIndex;
-        if (hasBundledElectron) {
-            // Bundled: renderer is in dist/electron/renderer
-            rendererIndex = path.join(electronPackagePath, 'renderer', 'index.html');
+        if (hasBundledDesktop) {
+            // Bundled: renderer is in dist/desktop/renderer
+            rendererIndex = path.join(desktopPackagePath, 'renderer', 'index.html');
         }
         else {
             // Local dev: renderer is in dist/renderer
-            rendererIndex = path.join(electronPackagePath, 'dist', 'renderer', 'index.html');
+            rendererIndex = path.join(desktopPackagePath, 'dist', 'renderer', 'index.html');
         }
         if (!fs.existsSync(rendererIndex)) {
-            if (hasBundledElectron) {
-                console.error('Error: Renderer files not found in bundled Electron app.');
+            if (hasBundledDesktop) {
+                console.error('Error: Renderer files not found in bundled Desktop app.');
                 console.error('This is a packaging issue. Please report this error.');
                 process.exit(1);
             }
@@ -724,9 +847,9 @@ program
             // Ensure NODE_ENV is not set to development when using bundled files
             process.env.NODE_ENV = 'production';
         }
-        // Automatically rebuild better-sqlite3 for Electron if needed
+        // Automatically rebuild better-sqlite3 for Desktop/Electron if needed
         // This ensures it's compiled for Electron's Node.js version
-        if (hasBundledElectron) {
+        if (hasBundledDesktop) {
             try {
                 const electronPkg = require('electron/package.json');
                 let rebuild;
@@ -746,7 +869,7 @@ program
                     const nodeModulesDir = path.dirname(betterSqlite3Dir); // .../node_modules
                     // The package root is the directory containing node_modules (i.e., projax package root)
                     const packageRoot = path.dirname(nodeModulesDir); // .../projax
-                    console.log('Ensuring better-sqlite3 is built for Electron...');
+                    console.log('Ensuring better-sqlite3 is built for Desktop/Electron...');
                     try {
                         await new Promise((resolve, reject) => {
                             rebuild({
@@ -756,7 +879,7 @@ program
                                 force: true,
                             })
                                 .then(() => {
-                                console.log('✓ better-sqlite3 ready for Electron');
+                                console.log('✓ better-sqlite3 ready for Desktop/Electron');
                                 resolve();
                             })
                                 .catch((err) => {
@@ -776,24 +899,66 @@ program
                 }
             }
             catch (checkError) {
-                // If we can't check, just continue - the error will show when Electron tries to use it
+                // If we can't check, just continue - the error will show when Desktop app tries to use it
             }
         }
-        console.log('Starting Electron app...');
+        console.log('Starting Desktop app...');
         const { spawn } = require('child_process');
         const electron = require('electron');
-        spawn(electron, [electronMainPath], {
+        spawn(electron, [desktopMainPath], {
             stdio: 'inherit',
             detached: true,
             env: { ...process.env },
         }).unref();
     }
     catch (error) {
-        console.error('Error starting Electron app:', error instanceof Error ? error.message : error);
+        console.error('Error starting Desktop app:', error instanceof Error ? error.message : error);
         console.log('\nTroubleshooting:');
         console.log('1. Try dev mode: prx web --dev');
-        console.log('2. Or build manually: npm run build:electron');
-        console.log('3. Or run dev server: cd packages/electron && npm run dev');
+        console.log('2. Or build manually: npm run build:desktop');
+        console.log('3. Or run dev server: cd packages/desktop && npm run dev');
+        process.exit(1);
+    }
+});
+// API command - show API info and manage API server
+program
+    .command('api')
+    .description('Show API server information and status')
+    .option('-s, --start', 'Start the API server')
+    .option('-k, --kill', 'Stop the API server')
+    .action(async (options) => {
+    try {
+        const apiStatus = await checkAPIStatus();
+        if (options.start) {
+            const started = await startAPIServer(false);
+            if (!started) {
+                process.exit(1);
+            }
+            return;
+        }
+        if (options.kill) {
+            console.log('Stopping API server...');
+            // This would require process management - for now just inform user
+            console.log('Note: API server process management not yet implemented.');
+            console.log('Please stop the API server manually if needed.');
+            return;
+        }
+        // Show status
+        console.log('\nAPI Server Status:');
+        console.log(`  Running: ${apiStatus.running ? 'Yes' : 'No'}`);
+        if (apiStatus.port) {
+            console.log(`  Port: ${apiStatus.port}`);
+            console.log(`  URL: http://localhost:${apiStatus.port}`);
+            console.log(`  Health: http://localhost:${apiStatus.port}/health`);
+            console.log(`  API Base: http://localhost:${apiStatus.port}/api`);
+        }
+        else {
+            console.log('  Port: Not detected');
+        }
+        console.log('');
+    }
+    catch (error) {
+        console.error('Error checking API status:', error instanceof Error ? error.message : error);
         process.exit(1);
     }
 });
@@ -805,9 +970,9 @@ program
     .action(async (projectIdentifier) => {
     try {
         const { scanProjectPorts, scanAllProjectPorts } = await Promise.resolve().then(() => __importStar(require('./port-scanner')));
-        const db = (0, core_1.getDatabaseManager)();
+        const db = (0, projax_core_1.getDatabaseManager)();
         if (projectIdentifier) {
-            const projects = (0, core_1.getAllProjects)();
+            const projects = (0, projax_core_1.getAllProjects)();
             const project = projects.find((p) => p.id.toString() === projectIdentifier || p.name === projectIdentifier);
             if (!project) {
                 console.error(`Error: Project not found: ${projectIdentifier}`);
@@ -830,7 +995,7 @@ program
         else {
             console.log('Scanning ports for all projects...\n');
             await scanAllProjectPorts();
-            const projects = (0, core_1.getAllProjects)();
+            const projects = (0, projax_core_1.getAllProjects)();
             for (const project of projects) {
                 const ports = db.getProjectPorts(project.id);
                 if (ports.length > 0) {
@@ -850,14 +1015,14 @@ 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', '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];
         // Check if it's actually a project (not a flag)
         if (!projectIdentifier.startsWith('-')) {
             try {
-                const projects = (0, core_1.getAllProjects)();
+                const projects = (0, projax_core_1.getAllProjects)();
                 // Try to find project by ID (if identifier is numeric) or by name
                 let project;
                 const numericId = parseInt(projectIdentifier, 10);

package/dist/port-scanner.js

@@ -36,14 +36,14 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.scanProjectPorts = scanProjectPorts;
 exports.scanAllProjectPorts = scanAllProjectPorts;
 exports.shouldRescanPorts = shouldRescanPorts;
-const core_1 = require("./core");
+const projax_core_1 = require("projax-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 db = (0, projax_core_1.getDatabaseManager)();
     const project = db.getProject(projectId);
     if (!project) {
         throw new Error(`Project with id ${projectId} not found`);
@@ -64,7 +64,7 @@ async function scanProjectPorts(projectId) {
  * Scan ports for all projects
  */
 async function scanAllProjectPorts() {
-    const db = (0, core_1.getDatabaseManager)();
+    const db = (0, projax_core_1.getDatabaseManager)();
     const projects = db.getAllProjects();
     for (const project of projects) {
         try {
@@ -81,7 +81,7 @@ async function scanAllProjectPorts() {
  * Returns true if ports haven't been scanned in the last 24 hours
  */
 function shouldRescanPorts(projectId) {
-    const db = (0, core_1.getDatabaseManager)();
+    const db = (0, projax_core_1.getDatabaseManager)();
     const ports = db.getProjectPorts(projectId);
     if (ports.length === 0) {
         return true; // No ports found, should scan

package/dist/script-runner.js

@@ -48,7 +48,7 @@ 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 projax_core_1 = require("projax-core");
 const port_utils_1 = require("./port-utils");
 /**
  * Detect the project type based on files in the directory
@@ -324,7 +324,7 @@ async function handlePortConflict(port, projectName, force) {
  * Check ports proactively before script execution
  */
 async function checkPortsBeforeExecution(projectPath, scriptName, force) {
-    const db = (0, core_1.getDatabaseManager)();
+    const db = (0, projax_core_1.getDatabaseManager)();
     const project = db.getProjectByPath(projectPath);
     if (!project)
         return true; // Can't check if project not in DB
@@ -447,7 +447,7 @@ function runScript(projectPath, scriptName, args = [], force = false) {
                 const errorOutput = stderrOutput + stdoutOutput;
                 const port = (0, port_utils_1.extractPortFromError)(errorOutput);
                 if (port) {
-                    const db = (0, core_1.getDatabaseManager)();
+                    const db = (0, projax_core_1.getDatabaseManager)();
                     const project = db.getProjectByPath(projectPath);
                     const projectName = project?.name || 'project';
                     const resolved = await handlePortConflict(port, projectName, force);
@@ -801,7 +801,7 @@ function runScriptInBackground(projectPath, projectName, scriptName, args = [],
         // Also check for URLs from detected ports
         setTimeout(async () => {
             try {
-                const db = (0, core_1.getDatabaseManager)();
+                const db = (0, projax_core_1.getDatabaseManager)();
                 const project = db.getProjectByPath(projectPath);
                 if (project) {
                     const ports = db.getProjectPorts(project.id);