dev3000 0.0.49 → 0.0.51

package/dist/dev-environment.js

@@ -1,11 +1,11 @@
-import { spawn } from 'child_process';
-import { writeFileSync, appendFileSync, mkdirSync, existsSync, copyFileSync, readFileSync, cpSync, lstatSync, symlinkSync, unlinkSync, readdirSync, statSync } from 'fs';
-import { join, dirname, basename } from 'path';
-import { fileURLToPath } from 'url';
-import { tmpdir } from 'os';
-import chalk from 'chalk';
-import ora from 'ora';
-import { CDPMonitor } from './cdp-monitor.js';
+import chalk from "chalk";
+import { spawn } from "child_process";
+import { appendFileSync, copyFileSync, cpSync, existsSync, lstatSync, mkdirSync, readdirSync, readFileSync, statSync, symlinkSync, unlinkSync, writeFileSync, } from "fs";
+import ora from "ora";
+import { tmpdir } from "os";
+import { basename, dirname, join } from "path";
+import { fileURLToPath } from "url";
+import { CDPMonitor } from "./cdp-monitor.js";
 class Logger {
     logFile;
     constructor(logFile) {
@@ -16,7 +16,7 @@ class Logger {
             mkdirSync(logDir, { recursive: true });
         }
         // Clear log file
-        writeFileSync(this.logFile, '');
+        writeFileSync(this.logFile, "");
     }
     log(source, message) {
         const timestamp = new Date().toISOString();
@@ -25,25 +25,25 @@ class Logger {
     }
 }
 function detectPackageManagerForRun() {
-    if (existsSync('pnpm-lock.yaml'))
-        return 'pnpm';
-    if (existsSync('yarn.lock'))
-        return 'yarn';
-    if (existsSync('package-lock.json'))
-        return 'npm';
-    return 'npm'; // fallback
+    if (existsSync("pnpm-lock.yaml"))
+        return "pnpm";
+    if (existsSync("yarn.lock"))
+        return "yarn";
+    if (existsSync("package-lock.json"))
+        return "npm";
+    return "npm"; // fallback
 }
 export function createPersistentLogFile() {
     // Create /var/log/dev3000 directory
-    const logBaseDir = '/var/log/dev3000';
+    const logBaseDir = "/var/log/dev3000";
     try {
         if (!existsSync(logBaseDir)) {
             mkdirSync(logBaseDir, { recursive: true });
         }
     }
-    catch (error) {
+    catch (_error) {
         // Fallback to user's temp directory if /var/log is not writable
-        const fallbackDir = join(tmpdir(), 'dev3000-logs');
+        const fallbackDir = join(tmpdir(), "dev3000-logs");
         if (!existsSync(fallbackDir)) {
             mkdirSync(fallbackDir, { recursive: true });
         }
@@ -53,26 +53,28 @@ export function createPersistentLogFile() {
 }
 function createLogFileInDir(baseDir) {
     // Get current working directory name
-    const cwdName = basename(process.cwd()).replace(/[^a-zA-Z0-9-_]/g, '_');
+    const cwdName = basename(process.cwd()).replace(/[^a-zA-Z0-9-_]/g, "_");
     // Create timestamp
-    const timestamp = new Date().toISOString().replace(/[:.]/g, '-');
+    const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
     // Create log file path
     const logFileName = `dev3000-${cwdName}-${timestamp}.log`;
     const logFilePath = join(baseDir, logFileName);
     // Prune old logs for this project (keep only 10 most recent)
     pruneOldLogs(baseDir, cwdName);
     // Create the log file
-    writeFileSync(logFilePath, '');
-    // Create or update symlink to /tmp/dev3000.log
-    const symlinkPath = '/tmp/dev3000.log';
-    try {
-        if (existsSync(symlinkPath)) {
-            unlinkSync(symlinkPath);
+    writeFileSync(logFilePath, "");
+    // Create or update symlinks to /tmp/dev3000.log and /tmp/d3k.log
+    const symlinkPaths = ["/tmp/dev3000.log", "/tmp/d3k.log"];
+    for (const symlinkPath of symlinkPaths) {
+        try {
+            if (existsSync(symlinkPath)) {
+                unlinkSync(symlinkPath);
+            }
+            symlinkSync(logFilePath, symlinkPath);
+        }
+        catch (error) {
+            console.warn(chalk.yellow(`⚠️ Could not create symlink ${symlinkPath}: ${error}`));
         }
-        symlinkSync(logFilePath, symlinkPath);
-    }
-    catch (error) {
-        console.warn(chalk.yellow(`⚠️ Could not create symlink ${symlinkPath}: ${error}`));
     }
     return logFilePath;
 }
@@ -80,11 +82,11 @@ function pruneOldLogs(baseDir, cwdName) {
     try {
         // Find all log files for this project
         const files = readdirSync(baseDir)
-            .filter(file => file.startsWith(`dev3000-${cwdName}-`) && file.endsWith('.log'))
-            .map(file => ({
+            .filter((file) => file.startsWith(`dev3000-${cwdName}-`) && file.endsWith(".log"))
+            .map((file) => ({
             name: file,
             path: join(baseDir, file),
-            mtime: statSync(join(baseDir, file)).mtime
+            mtime: statSync(join(baseDir, file)).mtime,
         }))
             .sort((a, b) => b.mtime.getTime() - a.mtime.getTime()); // Most recent first
         // Keep only the 10 most recent, delete the rest
@@ -94,7 +96,7 @@ function pruneOldLogs(baseDir, cwdName) {
                 try {
                     unlinkSync(file.path);
                 }
-                catch (error) {
+                catch (_error) {
                     // Silently ignore deletion errors
                 }
             }
@@ -124,35 +126,36 @@ export class DevEnvironment {
         const packageRoot = dirname(dirname(currentFile));
         // Always use MCP server's public directory for screenshots to ensure they're web-accessible
         // and avoid permission issues with /var/log paths
-        this.screenshotDir = join(packageRoot, 'mcp-server', 'public', 'screenshots');
-        this.pidFile = join(tmpdir(), 'dev3000.pid');
-        this.mcpPublicDir = join(packageRoot, 'mcp-server', 'public', 'screenshots');
+        this.screenshotDir = join(packageRoot, "mcp-server", "public", "screenshots");
+        this.pidFile = join(tmpdir(), "dev3000.pid");
+        this.mcpPublicDir = join(packageRoot, "mcp-server", "public", "screenshots");
         // Read version from package.json for startup message
-        this.version = '0.0.0';
+        this.version = "0.0.0";
         try {
-            const packageJsonPath = join(packageRoot, 'package.json');
-            const packageJson = JSON.parse(readFileSync(packageJsonPath, 'utf8'));
+            const packageJsonPath = join(packageRoot, "package.json");
+            const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf8"));
             this.version = packageJson.version;
             // Use git to detect if we're in the dev3000 source repository
             try {
-                const { execSync } = require('child_process');
-                const gitRemote = execSync('git remote get-url origin 2>/dev/null', {
+                const { execSync } = require("child_process");
+                const gitRemote = execSync("git remote get-url origin 2>/dev/null", {
                     cwd: packageRoot,
-                    encoding: 'utf8'
+                    encoding: "utf8",
                 }).trim();
-                if (gitRemote.includes('vercel-labs/dev3000') && !this.version.includes('canary')) {
-                    this.version += '-local';
+                if (gitRemote.includes("vercel-labs/dev3000") &&
+                    !this.version.includes("canary")) {
+                    this.version += "-local";
                 }
             }
             catch {
                 // Not in git repo or no git - use version as-is
             }
         }
-        catch (error) {
+        catch (_error) {
             // Use fallback version
         }
         // Initialize spinner for clean output management
-        this.spinner = ora({ text: 'Initializing...', spinner: 'dots' });
+        this.spinner = ora({ text: "Initializing...", spinner: "dots" });
         // Ensure directories exist
         if (!existsSync(this.screenshotDir)) {
             mkdirSync(this.screenshotDir, { recursive: true });
@@ -166,15 +169,16 @@ export class DevEnvironment {
         for (const port of ports) {
             try {
                 const result = await new Promise((resolve) => {
-                    const proc = spawn('lsof', ['-ti', `:${port}`], { stdio: 'pipe' });
-                    let output = '';
-                    proc.stdout?.on('data', (data) => output += data.toString());
-                    proc.on('exit', () => resolve(output.trim()));
+                    const proc = spawn("lsof", ["-ti", `:${port}`], { stdio: "pipe" });
+                    let output = "";
+                    // biome-ignore lint/suspicious/noAssignInExpressions: whatever
+                    proc.stdout?.on("data", (data) => (output += data.toString()));
+                    proc.on("exit", () => resolve(output.trim()));
                 });
                 if (result) {
-                    result.split('\n').filter(line => line.trim());
+                    result.split("\n").filter((line) => line.trim());
                     // Stop spinner and show error
-                    if (this.spinner && this.spinner.isSpinning) {
+                    if (this.spinner?.isSpinning) {
                         this.spinner.fail(`Port ${port} is already in use`);
                     }
                     console.log(chalk.yellow(`💡 To free up port ${port}, run: lsof -ti:${port} | xargs kill -9`));
@@ -182,7 +186,7 @@ export class DevEnvironment {
                 }
             }
             catch (error) {
-                if (error instanceof Error && error.message.includes('Port')) {
+                if (error instanceof Error && error.message.includes("Port")) {
                     throw error; // Re-throw our custom error
                 }
                 // Ignore other errors - port might just be free
@@ -191,77 +195,86 @@ export class DevEnvironment {
     }
     async start() {
         // Show startup message first
-        console.log(chalk.blue(`Starting dev3000 (v${this.version})`));
+        console.log(chalk.greenBright(`Starting ${this.options.commandName} (v${this.version})`));
         // Start spinner
-        this.spinner.start('Checking ports...');
+        this.spinner.start("Checking ports...");
         // Check if ports are available first
         await this.checkPortsAvailable();
-        this.spinner.text = 'Setting up environment...';
+        this.spinner.text = "Setting up environment...";
         // Write our process group ID to PID file for cleanup
         writeFileSync(this.pidFile, process.pid.toString());
         // Setup cleanup handlers
         this.setupCleanupHandlers();
         // Start user's dev server
-        this.spinner.text = 'Starting your dev server...';
+        this.spinner.text = "Starting your dev server...";
         await this.startServer();
         // Start MCP server
-        this.spinner.text = 'Starting dev3000 services...';
+        this.spinner.text = `Starting ${this.options.commandName} services...`;
         await this.startMcpServer();
         // Wait for servers to be ready
-        this.spinner.text = 'Waiting for your app server...';
+        this.spinner.text = "Waiting for your app server...";
         await this.waitForServer();
-        this.spinner.text = 'Waiting for dev3000 services...';
+        this.spinner.text = `Waiting for ${this.options.commandName} services...`;
         await this.waitForMcpServer();
-        // Start CDP monitoring but don't wait for full setup
-        this.spinner.text = 'Launching browser monitor...';
-        this.startCDPMonitoringAsync();
+        // Start CDP monitoring if not in servers-only mode
+        if (!this.options.serversOnly) {
+            this.spinner.text = "Launching browser monitor...";
+            this.startCDPMonitoringAsync();
+        }
+        else {
+            this.debugLog("Browser monitoring disabled via --servers-only flag");
+        }
         // Complete startup
-        this.spinner.succeed('Development environment ready!');
-        console.log(chalk.blue(`Logs: ${this.options.logFile}`));
-        console.log(chalk.blue(`Logs symlink: /tmp/dev3000.log`));
-        console.log(chalk.yellow('☝️ Give this to an AI to auto debug and fix your app\n'));
-        console.log(chalk.blue(`🌐 Your App: http://localhost:${this.options.port}`));
-        console.log(chalk.blue(`🤖 MCP Server: http://localhost:${this.options.mcpPort}/api/mcp/mcp`));
-        console.log(chalk.magenta(`📸 Visual Timeline: http://localhost:${this.options.mcpPort}/logs`));
-        console.log(chalk.gray('\n💡 To stop all servers and kill dev3000: Ctrl-C'));
+        this.spinner.succeed("Development environment ready!");
+        console.log(chalk.cyan(`Logs: /tmp/d3k.log -> ${this.options.logFile}`));
+        console.log(chalk.cyan("☝️ Give this to an AI to auto debug and fix your app\n"));
+        console.log(chalk.cyan(`🌐 Your App: http://localhost:${this.options.port}`));
+        console.log(chalk.cyan(`🤖 MCP Server: http://localhost:${this.options.mcpPort}/api/mcp/mcp`));
+        console.log(chalk.cyan(`📸 Visual Timeline: http://localhost:${this.options.mcpPort}/logs`));
+        if (this.options.serversOnly) {
+            console.log(chalk.cyan("🖥️  Servers-only mode - use Chrome extension for browser monitoring"));
+        }
+        console.log(chalk.gray(`\n💡 To stop all servers and kill ${this.options.commandName}: Ctrl-C`));
     }
     async startServer() {
-        const [command, ...args] = this.options.serverCommand.split(' ');
+        const [command, ...args] = this.options.serverCommand.split(" ");
         this.serverProcess = spawn(command, args, {
-            stdio: ['ignore', 'pipe', 'pipe'],
+            stdio: ["ignore", "pipe", "pipe"],
             shell: true,
             detached: true, // Run independently
         });
         // Log server output (to file only, reduce stdout noise)
-        this.serverProcess.stdout?.on('data', (data) => {
+        this.serverProcess.stdout?.on("data", (data) => {
             const message = data.toString().trim();
             if (message) {
-                this.logger.log('server', message);
+                this.logger.log("server", message);
             }
         });
-        this.serverProcess.stderr?.on('data', (data) => {
+        this.serverProcess.stderr?.on("data", (data) => {
             const message = data.toString().trim();
             if (message) {
-                this.logger.log('server', `ERROR: ${message}`);
+                this.logger.log("server", `ERROR: ${message}`);
                 // Suppress build errors and common dev errors from console output
                 // They're still logged to file for debugging
                 // Only show truly critical errors that would prevent startup
-                const isCriticalError = message.includes('EADDRINUSE') ||
-                    message.includes('EACCES') ||
-                    message.includes('ENOENT') ||
-                    (message.includes('FATAL') && !message.includes('generateStaticParams')) ||
-                    (message.includes('Cannot find module') && !message.includes('.next'));
+                const isCriticalError = message.includes("EADDRINUSE") ||
+                    message.includes("EACCES") ||
+                    message.includes("ENOENT") ||
+                    (message.includes("FATAL") &&
+                        !message.includes("generateStaticParams")) ||
+                    (message.includes("Cannot find module") &&
+                        !message.includes(".next"));
                 if (isCriticalError) {
-                    console.error(chalk.red('[CRITICAL ERROR]'), message);
+                    console.error(chalk.red("[CRITICAL ERROR]"), message);
                 }
             }
         });
-        this.serverProcess.on('exit', (code) => {
+        this.serverProcess.on("exit", (code) => {
             if (this.isShuttingDown)
                 return; // Don't handle exits during shutdown
             if (code !== 0 && code !== null) {
                 this.debugLog(`Server process exited with code ${code}`);
-                this.logger.log('server', `Server process exited with code ${code}`);
+                this.logger.log("server", `Server process exited with code ${code}`);
                 // Only shutdown for truly fatal exit codes, not build failures or restarts
                 // Common exit codes that indicate temporary issues, not fatal errors:
                 // - Code 1: Generic build failure or restart
@@ -270,19 +283,19 @@ export class DevEnvironment {
                 const isFatalExit = code !== 1 && code !== 130 && code !== 143;
                 if (isFatalExit) {
                     // Stop spinner and show error for fatal exits only
-                    if (this.spinner && this.spinner.isSpinning) {
+                    if (this.spinner?.isSpinning) {
                         this.spinner.fail(`Server process fatally exited with code ${code}`);
                     }
                     else {
                         console.log(chalk.red(`\n❌ Server process fatally exited with code ${code}`));
                     }
-                    console.log(chalk.yellow('💡 Check your server command and logs for details'));
+                    console.log(chalk.yellow("💡 Check your server command and logs for details"));
                     this.gracefulShutdown();
                 }
                 else {
                     // For non-fatal exits (like build failures), just log and continue
-                    if (this.spinner && this.spinner.isSpinning) {
-                        this.spinner.text = 'Server process restarted, waiting...';
+                    if (this.spinner?.isSpinning) {
+                        this.spinner.text = "Server process restarted, waiting...";
                     }
                 }
             }
@@ -290,7 +303,7 @@ export class DevEnvironment {
     }
     debugLog(message) {
         if (this.options.debug) {
-            if (this.spinner && this.spinner.isSpinning) {
+            if (this.spinner?.isSpinning) {
                 // Temporarily stop the spinner, show debug message, then restart
                 const currentText = this.spinner.text;
                 this.spinner.stop();
@@ -303,40 +316,46 @@ export class DevEnvironment {
         }
     }
     async startMcpServer() {
-        this.debugLog('Starting MCP server setup');
+        this.debugLog("Starting MCP server setup");
         // Get the path to our bundled MCP server
         const currentFile = fileURLToPath(import.meta.url);
         const packageRoot = dirname(dirname(currentFile)); // Go up from dist/ to package root
-        const mcpServerPath = join(packageRoot, 'mcp-server');
+        const mcpServerPath = join(packageRoot, "mcp-server");
         this.debugLog(`MCP server path: ${mcpServerPath}`);
         if (!existsSync(mcpServerPath)) {
             throw new Error(`MCP server directory not found at ${mcpServerPath}`);
         }
-        this.debugLog('MCP server directory found');
+        this.debugLog("MCP server directory found");
         // Check if MCP server dependencies are installed, install if missing
-        const isGlobalInstall = mcpServerPath.includes('.pnpm');
+        const isGlobalInstall = mcpServerPath.includes(".pnpm");
         this.debugLog(`Is global install: ${isGlobalInstall}`);
-        let nodeModulesPath = join(mcpServerPath, 'node_modules');
+        let nodeModulesPath = join(mcpServerPath, "node_modules");
         let actualWorkingDir = mcpServerPath;
         this.debugLog(`Node modules path: ${nodeModulesPath}`);
         if (isGlobalInstall) {
-            const tmpDirPath = join(tmpdir(), 'dev3000-mcp-deps');
-            nodeModulesPath = join(tmpDirPath, 'node_modules');
+            const tmpDirPath = join(tmpdir(), "dev3000-mcp-deps");
+            nodeModulesPath = join(tmpDirPath, "node_modules");
             actualWorkingDir = tmpDirPath;
             // Update screenshot and MCP public directory to use the temp directory for global installs
-            this.screenshotDir = join(actualWorkingDir, 'public', 'screenshots');
-            this.mcpPublicDir = join(actualWorkingDir, 'public', 'screenshots');
+            this.screenshotDir = join(actualWorkingDir, "public", "screenshots");
+            this.mcpPublicDir = join(actualWorkingDir, "public", "screenshots");
             if (!existsSync(this.mcpPublicDir)) {
                 mkdirSync(this.mcpPublicDir, { recursive: true });
             }
         }
         // Always install dependencies to ensure they're up to date
-        this.debugLog('Installing/updating MCP server dependencies');
+        this.debugLog("Installing/updating MCP server dependencies");
         await this.installMcpServerDeps(mcpServerPath);
         // Use version already read in constructor
         // For global installs, ensure all necessary files are copied to temp directory
         if (isGlobalInstall && actualWorkingDir !== mcpServerPath) {
-            const requiredFiles = ['app', 'public', 'next.config.ts', 'next-env.d.ts', 'tsconfig.json'];
+            const requiredFiles = [
+                "app",
+                "public",
+                "next.config.ts",
+                "next-env.d.ts",
+                "tsconfig.json",
+            ];
             for (const file of requiredFiles) {
                 const srcPath = join(mcpServerPath, file);
                 const destPath = join(actualWorkingDir, file);
@@ -353,7 +372,7 @@ export class DevEnvironment {
                         // Remove existing destination if it exists
                         if (existsSync(destPath)) {
                             if (lstatSync(destPath).isDirectory()) {
-                                cpSync(destPath, destPath + '.bak', { recursive: true });
+                                cpSync(destPath, `${destPath}.bak`, { recursive: true });
                                 cpSync(srcPath, destPath, { recursive: true, force: true });
                             }
                             else {
@@ -378,8 +397,8 @@ export class DevEnvironment {
         this.debugLog(`Using package manager: ${packageManagerForRun}`);
         this.debugLog(`MCP server working directory: ${actualWorkingDir}`);
         this.debugLog(`MCP server port: ${this.options.mcpPort}`);
-        this.mcpServerProcess = spawn(packageManagerForRun, ['run', 'dev'], {
-            stdio: ['ignore', 'pipe', 'pipe'],
+        this.mcpServerProcess = spawn(packageManagerForRun, ["run", "dev"], {
+            stdio: ["ignore", "pipe", "pipe"],
             shell: true,
             detached: true, // Run independently
             cwd: actualWorkingDir,
@@ -390,36 +409,36 @@ export class DevEnvironment {
                 DEV3000_VERSION: this.version, // Pass version to MCP server
             },
         });
-        this.debugLog('MCP server process spawned');
+        this.debugLog("MCP server process spawned");
         // Log MCP server output to separate file for debugging
-        const mcpLogFile = join(dirname(this.options.logFile), 'dev3000-mcp.log');
-        writeFileSync(mcpLogFile, ''); // Clear the file
-        this.mcpServerProcess.stdout?.on('data', (data) => {
+        const mcpLogFile = join(dirname(this.options.logFile), "dev3000-mcp.log");
+        writeFileSync(mcpLogFile, ""); // Clear the file
+        this.mcpServerProcess.stdout?.on("data", (data) => {
             const message = data.toString().trim();
             if (message) {
                 const timestamp = new Date().toISOString();
                 appendFileSync(mcpLogFile, `[${timestamp}] [MCP-STDOUT] ${message}\n`);
             }
         });
-        this.mcpServerProcess.stderr?.on('data', (data) => {
+        this.mcpServerProcess.stderr?.on("data", (data) => {
             const message = data.toString().trim();
             if (message) {
                 const timestamp = new Date().toISOString();
                 appendFileSync(mcpLogFile, `[${timestamp}] [MCP-STDERR] ${message}\n`);
                 // Only show critical errors in stdout for debugging
-                if (message.includes('FATAL') || message.includes('Error:')) {
-                    console.error(chalk.red('[LOG VIEWER ERROR]'), message);
+                if (message.includes("FATAL") || message.includes("Error:")) {
+                    console.error(chalk.red("[LOG VIEWER ERROR]"), message);
                 }
             }
         });
-        this.mcpServerProcess.on('exit', (code) => {
+        this.mcpServerProcess.on("exit", (code) => {
             this.debugLog(`MCP server process exited with code ${code}`);
             // Only show exit messages for unexpected failures, not restarts
             if (code !== 0 && code !== null) {
-                this.logger.log('server', `MCP server process exited with code ${code}`);
+                this.logger.log("server", `MCP server process exited with code ${code}`);
             }
         });
-        this.debugLog('MCP server event handlers setup complete');
+        this.debugLog("MCP server event handlers setup complete");
     }
     async waitForServer() {
         const maxAttempts = 30;
@@ -427,18 +446,18 @@ export class DevEnvironment {
         while (attempts < maxAttempts) {
             try {
                 const response = await fetch(`http://localhost:${this.options.port}`, {
-                    method: 'HEAD',
-                    signal: AbortSignal.timeout(2000)
+                    method: "HEAD",
+                    signal: AbortSignal.timeout(2000),
                 });
                 if (response.ok || response.status === 404) {
                     return;
                 }
             }
-            catch (error) {
+            catch (_error) {
                 // Server not ready yet, continue waiting
             }
             attempts++;
-            await new Promise(resolve => setTimeout(resolve, 1000));
+            await new Promise((resolve) => setTimeout(resolve, 1000));
         }
         // Continue anyway if health check fails
     }
@@ -446,44 +465,46 @@ export class DevEnvironment {
         return new Promise((resolve, reject) => {
             // For global installs, we need to install to a writable location
             // Check if this is a global install by looking for .pnpm in the path
-            const isGlobalInstall = mcpServerPath.includes('.pnpm');
+            const isGlobalInstall = mcpServerPath.includes(".pnpm");
             let workingDir = mcpServerPath;
             if (isGlobalInstall) {
                 // Create a writable copy in temp directory for global installs
-                const tmpDirPath = join(tmpdir(), 'dev3000-mcp-deps');
+                const tmpDirPath = join(tmpdir(), "dev3000-mcp-deps");
                 // Ensure tmp directory exists
                 if (!existsSync(tmpDirPath)) {
                     mkdirSync(tmpDirPath, { recursive: true });
                 }
-                // Copy package.json to temp directory if it doesn't exist
-                const tmpPackageJson = join(tmpDirPath, 'package.json');
-                if (!existsSync(tmpPackageJson)) {
-                    const sourcePackageJson = join(mcpServerPath, 'package.json');
-                    copyFileSync(sourcePackageJson, tmpPackageJson);
-                }
+                // Always copy package.json to temp directory to ensure it's up to date
+                const tmpPackageJson = join(tmpDirPath, "package.json");
+                const sourcePackageJson = join(mcpServerPath, "package.json");
+                copyFileSync(sourcePackageJson, tmpPackageJson);
                 workingDir = tmpDirPath;
             }
             const packageManager = detectPackageManagerForRun();
             // Don't show any console output during dependency installation
             // All status will be handled by the progress bar
-            const installProcess = spawn(packageManager, ['install'], {
-                stdio: ['ignore', 'pipe', 'pipe'],
+            // For pnpm, use --dev flag to include devDependencies
+            const installArgs = packageManager === "pnpm"
+                ? ["install", "--prod=false"] // Install both prod and dev dependencies
+                : ["install", "--include=dev"]; // npm/yarn syntax
+            const installProcess = spawn(packageManager, installArgs, {
+                stdio: ["ignore", "pipe", "pipe"],
                 shell: true,
                 cwd: workingDir,
             });
             // Add timeout (3 minutes)
             const timeout = setTimeout(() => {
-                installProcess.kill('SIGKILL');
-                reject(new Error('MCP server dependency installation timed out after 3 minutes'));
+                installProcess.kill("SIGKILL");
+                reject(new Error("MCP server dependency installation timed out after 3 minutes"));
             }, 3 * 60 * 1000);
             // Suppress all output to prevent progress bar interference
-            installProcess.stdout?.on('data', (data) => {
+            installProcess.stdout?.on("data", (_data) => {
                 // Silently consume output
             });
-            installProcess.stderr?.on('data', (data) => {
+            installProcess.stderr?.on("data", (_data) => {
                 // Silently consume output
             });
-            installProcess.on('exit', (code) => {
+            installProcess.on("exit", (code) => {
                 clearTimeout(timeout);
                 if (code === 0) {
                     resolve();
@@ -492,7 +513,7 @@ export class DevEnvironment {
                     reject(new Error(`MCP server dependency installation failed with exit code ${code}`));
                 }
             });
-            installProcess.on('error', (error) => {
+            installProcess.on("error", (error) => {
                 clearTimeout(timeout);
                 reject(new Error(`Failed to start MCP server dependency installation: ${error.message}`));
             });
@@ -505,15 +526,16 @@ export class DevEnvironment {
             try {
                 // Test the actual MCP endpoint
                 const response = await fetch(`http://localhost:${this.options.mcpPort}`, {
-                    method: 'HEAD',
-                    signal: AbortSignal.timeout(2000)
+                    method: "HEAD",
+                    signal: AbortSignal.timeout(2000),
                 });
                 this.debugLog(`MCP server health check: ${response.status}`);
                 if (response.status === 500) {
                     const errorText = await response.text();
                     this.debugLog(`MCP server 500 error: ${errorText}`);
                 }
-                if (response.ok || response.status === 404) { // 404 is OK - means server is responding
+                if (response.ok || response.status === 404) {
+                    // 404 is OK - means server is responding
                     return;
                 }
             }
@@ -521,39 +543,48 @@ export class DevEnvironment {
                 this.debugLog(`MCP server not ready (attempt ${attempts}): ${error}`);
             }
             attempts++;
-            await new Promise(resolve => setTimeout(resolve, 1000));
+            await new Promise((resolve) => setTimeout(resolve, 1000));
         }
-        this.debugLog('MCP server health check failed, terminating');
+        this.debugLog("MCP server health check failed, terminating");
         throw new Error(`MCP server failed to start after ${maxAttempts} seconds. Check the logs for errors.`);
     }
     startCDPMonitoringAsync() {
+        // Skip if in servers-only mode
+        if (this.options.serversOnly) {
+            return;
+        }
         // Start CDP monitoring in background without blocking completion
-        this.startCDPMonitoring().catch(error => {
-            console.error(chalk.red('⚠️ CDP monitoring setup failed:'), error);
+        this.startCDPMonitoring().catch((error) => {
+            console.error(chalk.red("⚠️ CDP monitoring setup failed:"), error);
             // CDP monitoring is critical - shutdown if it fails
             this.gracefulShutdown();
         });
     }
     async startCDPMonitoring() {
+        // Skip if in servers-only mode
+        if (this.options.serversOnly) {
+            this.debugLog("Browser monitoring disabled via --servers-only flag");
+            return;
+        }
         // Ensure profile directory exists
         if (!existsSync(this.options.profileDir)) {
             mkdirSync(this.options.profileDir, { recursive: true });
         }
         // Initialize CDP monitor with enhanced logging - use MCP public directory for screenshots
-        this.cdpMonitor = new CDPMonitor(this.options.profileDir, this.mcpPublicDir, (source, message) => {
-            this.logger.log('browser', message);
+        this.cdpMonitor = new CDPMonitor(this.options.profileDir, this.mcpPublicDir, (_source, message) => {
+            this.logger.log("browser", message);
         }, this.options.debug);
         try {
             // Start CDP monitoring
             await this.cdpMonitor.start();
-            this.logger.log('browser', '[CDP] Chrome launched with DevTools Protocol monitoring');
+            this.logger.log("browser", "[CDP] Chrome launched with DevTools Protocol monitoring");
             // Navigate to the app
             await this.cdpMonitor.navigateToApp(this.options.port);
-            this.logger.log('browser', `[CDP] Navigated to http://localhost:${this.options.port}`);
+            this.logger.log("browser", `[CDP] Navigated to http://localhost:${this.options.port}`);
         }
         catch (error) {
             // Log error and throw to trigger graceful shutdown
-            this.logger.log('browser', `[CDP ERROR] Failed to start CDP monitoring: ${error}`);
+            this.logger.log("browser", `[CDP ERROR] Failed to start CDP monitoring: ${error}`);
             throw error;
         }
     }
@@ -562,17 +593,17 @@ export class DevEnvironment {
             return; // Prevent multiple shutdown attempts
         this.isShuttingDown = true;
         // Stop spinner if it's running
-        if (this.spinner && this.spinner.isSpinning) {
-            this.spinner.fail('Critical failure detected');
+        if (this.spinner?.isSpinning) {
+            this.spinner.fail("Critical failure detected");
         }
-        console.log(chalk.yellow('🛑 Shutting down dev3000 due to critical failure...'));
+        console.log(chalk.yellow(`🛑 Shutting down ${this.options.commandName} due to critical failure...`));
         // Kill processes on both ports
         const killPortProcess = async (port, name) => {
             try {
-                const { spawn } = await import('child_process');
-                const killProcess = spawn('sh', ['-c', `lsof -ti:${port} | xargs kill -9`], { stdio: 'inherit' });
+                const { spawn } = await import("child_process");
+                const killProcess = spawn("sh", ["-c", `lsof -ti:${port} | xargs kill -9`], { stdio: "inherit" });
                 return new Promise((resolve) => {
-                    killProcess.on('exit', (code) => {
+                    killProcess.on("exit", (code) => {
                         if (code === 0) {
                             console.log(chalk.green(`✅ Killed ${name} on port ${port}`));
                         }
@@ -580,48 +611,48 @@ export class DevEnvironment {
                     });
                 });
             }
-            catch (error) {
+            catch (_error) {
                 console.log(chalk.gray(`⚠️ Could not kill ${name} on port ${port}`));
             }
         };
         // Kill servers
-        console.log(chalk.blue('🔄 Killing servers...'));
+        console.log(chalk.cyan("🔄 Killing servers..."));
         await Promise.all([
-            killPortProcess(this.options.port, 'your app server'),
-            killPortProcess(this.options.mcpPort, 'dev3000 MCP server')
+            killPortProcess(this.options.port, "your app server"),
+            killPortProcess(this.options.mcpPort, `${this.options.commandName} MCP server`),
         ]);
-        // Shutdown CDP monitor
+        // Shutdown CDP monitor if it was started
         if (this.cdpMonitor) {
             try {
-                console.log(chalk.blue('🔄 Closing CDP monitor...'));
+                console.log(chalk.cyan("🔄 Closing CDP monitor..."));
                 await this.cdpMonitor.shutdown();
-                console.log(chalk.green('✅ CDP monitor closed'));
+                console.log(chalk.green("✅ CDP monitor closed"));
             }
-            catch (error) {
-                console.log(chalk.gray('⚠️ CDP monitor shutdown failed'));
+            catch (_error) {
+                console.log(chalk.gray("⚠️ CDP monitor shutdown failed"));
             }
         }
-        console.log(chalk.red('❌ Dev3000 exited due to server failure'));
+        console.log(chalk.red(`❌ ${this.options.commandName} exited due to server failure`));
         process.exit(1);
     }
     setupCleanupHandlers() {
         // Handle Ctrl+C to kill all processes
-        process.on('SIGINT', async () => {
+        process.on("SIGINT", async () => {
             if (this.isShuttingDown)
                 return; // Prevent multiple shutdown attempts
             this.isShuttingDown = true;
             // Stop spinner if it's running
-            if (this.spinner && this.spinner.isSpinning) {
-                this.spinner.fail('Interrupted');
+            if (this.spinner?.isSpinning) {
+                this.spinner.fail("Interrupted");
             }
-            console.log(chalk.yellow('\n🛑 Received interrupt signal. Cleaning up processes...'));
+            console.log(chalk.yellow("\n🛑 Received interrupt signal. Cleaning up processes..."));
             // Kill processes on both ports FIRST - this is most important
             const killPortProcess = async (port, name) => {
                 try {
-                    const { spawn } = await import('child_process');
-                    const killProcess = spawn('sh', ['-c', `lsof -ti:${port} | xargs kill -9`], { stdio: 'inherit' });
+                    const { spawn } = await import("child_process");
+                    const killProcess = spawn("sh", ["-c", `lsof -ti:${port} | xargs kill -9`], { stdio: "inherit" });
                     return new Promise((resolve) => {
-                        killProcess.on('exit', (code) => {
+                        killProcess.on("exit", (code) => {
                             if (code === 0) {
                                 console.log(chalk.green(`✅ Killed ${name} on port ${port}`));
                             }
@@ -629,28 +660,28 @@ export class DevEnvironment {
                         });
                     });
                 }
-                catch (error) {
+                catch (_error) {
                     console.log(chalk.gray(`⚠️ Could not kill ${name} on port ${port}`));
                 }
             };
             // Kill servers immediately - don't wait for browser cleanup
-            console.log(chalk.blue('🔄 Killing servers...'));
+            console.log(chalk.yellow("🔄 Killing servers..."));
             await Promise.all([
-                killPortProcess(this.options.port, 'your app server'),
-                killPortProcess(this.options.mcpPort, 'dev3000 MCP server')
+                killPortProcess(this.options.port, "your app server"),
+                killPortProcess(this.options.mcpPort, `${this.options.commandName} MCP server`),
             ]);
-            // Shutdown CDP monitor
+            // Shutdown CDP monitor if it was started
             if (this.cdpMonitor) {
                 try {
-                    console.log(chalk.blue('🔄 Closing CDP monitor...'));
+                    console.log(chalk.cyan("🔄 Closing CDP monitor..."));
                     await this.cdpMonitor.shutdown();
-                    console.log(chalk.green('✅ CDP monitor closed'));
+                    console.log(chalk.green("✅ CDP monitor closed"));
                 }
-                catch (error) {
-                    console.log(chalk.gray('⚠️ CDP monitor shutdown failed'));
+                catch (_error) {
+                    console.log(chalk.gray("⚠️ CDP monitor shutdown failed"));
                 }
             }
-            console.log(chalk.green('✅ Cleanup complete'));
+            console.log(chalk.green("✅ Cleanup complete"));
             process.exit(0);
         });
     }