dev3000 0.0.173 → 0.0.175

package/dist/dev-environment.js

@@ -2,7 +2,7 @@ import chalk from "chalk";
 import { execSync, spawn, spawnSync } from "child_process";
 import { appendFileSync, copyFileSync, existsSync, mkdirSync, readdirSync, readFileSync, statSync, unlinkSync, writeFileSync } from "fs";
 import https from "https";
-import { createServer } from "net";
+import { createConnection, createServer } from "net";
 import ora from "ora";
 import { homedir, tmpdir } from "os";
 import { dirname, join, resolve, sep } from "path";
@@ -12,8 +12,9 @@ import { CDPMonitor } from "./cdp-monitor.js";
 import { ensurePortlessAlias, getPortlessUrl, isPortlessInstalled, removePortlessAlias } from "./portless.js";
 import { ScreencastManager } from "./screencast-manager.js";
 import { NextJsErrorDetector, OutputProcessor, StandardLogParser } from "./services/parsers/index.js";
-import { getBundledSkillsPath, listAvailableSkills } from "./skills/index.js";
+import { getBundledD3kSkillPath, listAvailableSkills } from "./skills/index.js";
 import { DevTUI } from "./tui-interface.js";
+import { readProjectAgentName, rememberProjectAgentName } from "./utils/project-metadata.js";
 import { getProjectDir, getProjectDisplayName, getProjectName } from "./utils/project-name.js";
 import { getApplicablePackages, getSkillsPathForLocation, installSkillPackage, isPackageInstalled } from "./utils/skill-installer.js";
 import { formatTimestamp } from "./utils/timestamp.js";
@@ -102,8 +103,8 @@ class Logger {
         if (!existsSync(logDir)) {
             mkdirSync(logDir, { recursive: true });
         }
-        // Clear log file
-        writeFileSync(this.logFile, "");
+        // Touch the log file without truncating an explicit existing --log-file.
+        appendFileSync(this.logFile, "");
     }
     log(source, message) {
         const timestamp = formatTimestamp(new Date(), this.dateTimeFormat);
@@ -125,6 +126,68 @@ function isInSandbox() {
         existsSync("/.dockerenv") ||
         existsSync("/run/.containerenv"));
 }
+function parsePortNumber(port) {
+    if (!/^\d+$/.test(port)) {
+        return null;
+    }
+    const parsed = Number.parseInt(port, 10);
+    if (!Number.isInteger(parsed) || parsed < 1 || parsed > 65535) {
+        return null;
+    }
+    return parsed;
+}
+function escapeRegexForPkill(value) {
+    return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+function killPortProcessesSync(port, debugLog) {
+    if (isInSandbox()) {
+        debugLog(`Skipping synchronous port kill in sandbox environment`);
+        return;
+    }
+    const parsedPort = parsePortNumber(port);
+    if (parsedPort === null) {
+        debugLog(`Skipping synchronous port kill for invalid port: ${port}`);
+        return;
+    }
+    try {
+        const result = spawnSync("lsof", ["-ti", `:${parsedPort}`], {
+            stdio: ["ignore", "pipe", "pipe"],
+            encoding: "utf8",
+            timeout: 5000
+        });
+        const pidStrings = result.stdout
+            .split(/\s+/)
+            .map((value) => value.trim())
+            .filter((value) => /^\d+$/.test(value));
+        for (const pidString of pidStrings) {
+            try {
+                process.kill(Number.parseInt(pidString, 10), "SIGKILL");
+            }
+            catch (error) {
+                debugLog(`Failed to synchronously kill PID ${pidString} on port ${parsedPort}: ${error}`);
+            }
+        }
+        debugLog(`Synchronous kill for port ${parsedPort} found ${pidStrings.length} process(es)`);
+    }
+    catch (error) {
+        debugLog(`Synchronous kill error for port ${parsedPort}: ${error}`);
+    }
+}
+function pkillByPattern(pattern, debugLog) {
+    if (isInSandbox()) {
+        debugLog(`Skipping pkill in sandbox environment`);
+        return;
+    }
+    try {
+        spawnSync("pkill", ["-f", pattern], {
+            stdio: "ignore",
+            timeout: 5000
+        });
+    }
+    catch (error) {
+        debugLog(`pkill failed for pattern ${pattern}: ${error}`);
+    }
+}
 /**
  * Count active d3k instances by checking PID files in tmpdir.
  * Returns the count of running d3k processes (excluding the current one if specified).
@@ -163,6 +226,115 @@ export function countActiveD3kInstances(excludeCurrentPid = false) {
         return excludeCurrentPid ? 0 : 1;
     }
 }
+export function parseD3kLockContent(content) {
+    const trimmed = content.trim();
+    if (!trimmed)
+        return null;
+    if (/^\d+$/.test(trimmed)) {
+        const pid = Number.parseInt(trimmed, 10);
+        return Number.isInteger(pid) && pid > 0 ? { pid } : null;
+    }
+    try {
+        const parsed = JSON.parse(trimmed);
+        const pid = parsed?.pid;
+        if (!parsed || typeof parsed !== "object" || typeof pid !== "number" || !Number.isInteger(pid) || pid <= 0) {
+            return null;
+        }
+        return {
+            pid,
+            cwd: typeof parsed.cwd === "string" ? parsed.cwd : null,
+            createdAt: typeof parsed.createdAt === "string" ? parsed.createdAt : null,
+            processStartTime: typeof parsed.processStartTime === "string" ? parsed.processStartTime : null
+        };
+    }
+    catch {
+        return null;
+    }
+}
+function getProcessPsField(pid, field) {
+    try {
+        const result = spawnSync("ps", ["-p", String(pid), "-o", `${field}=`], {
+            encoding: "utf8",
+            stdio: ["ignore", "pipe", "ignore"]
+        });
+        if (result.status !== 0)
+            return null;
+        const output = result.stdout.trim();
+        return output || null;
+    }
+    catch {
+        return null;
+    }
+}
+export function getProcessStartTime(pid) {
+    return getProcessPsField(pid, "lstart");
+}
+export function getProcessCommand(pid) {
+    return getProcessPsField(pid, "command");
+}
+function isLikelyD3kCommand(command) {
+    const normalized = command.toLowerCase();
+    return normalized.includes("d3k") || normalized.includes("dev3000");
+}
+export function validateD3kLockContent(content, deps = {}) {
+    const lockInfo = parseD3kLockContent(content);
+    if (!lockInfo) {
+        return {
+            active: false,
+            reason: "lock file contents are invalid",
+            lockInfo: null
+        };
+    }
+    const processExists = deps.processExists ||
+        ((pid) => {
+            try {
+                process.kill(pid, 0);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        });
+    if (!processExists(lockInfo.pid)) {
+        return {
+            active: false,
+            reason: `process ${lockInfo.pid} is not running`,
+            lockInfo
+        };
+    }
+    const getStartTime = deps.getProcessStartTime || getProcessStartTime;
+    if (lockInfo.processStartTime) {
+        const liveStartTime = getStartTime(lockInfo.pid);
+        if (liveStartTime && liveStartTime !== lockInfo.processStartTime) {
+            return {
+                active: false,
+                reason: `pid ${lockInfo.pid} was reused by a different process`,
+                lockInfo
+            };
+        }
+        if (liveStartTime === lockInfo.processStartTime) {
+            return {
+                active: true,
+                reason: `process ${lockInfo.pid} matches recorded start time`,
+                lockInfo
+            };
+        }
+    }
+    const getCommand = deps.getProcessCommand || getProcessCommand;
+    const liveCommand = getCommand(lockInfo.pid);
+    if (liveCommand && !isLikelyD3kCommand(liveCommand)) {
+        return {
+            active: false,
+            reason: `pid ${lockInfo.pid} belongs to a non-d3k process`,
+            lockInfo
+        };
+    }
+    return {
+        active: true,
+        reason: `process ${lockInfo.pid} still owns the lock`,
+        lockInfo
+    };
+}
 /**
  * Check if a port is available for binding (no process is listening on it).
  * Used for finding available ports before starting servers.
@@ -172,6 +344,40 @@ async function isPortAvailable(port) {
     if (!Number.isInteger(portNumber) || portNumber < 0 || portNumber > 65535) {
         return false;
     }
+    const hasActiveListener = await Promise.any(["127.0.0.1", "::1", "localhost"].map((host) => new Promise((resolve, reject) => {
+        const socket = createConnection({ host, port: portNumber });
+        let settled = false;
+        const finish = (result, shouldReject = false) => {
+            if (settled)
+                return;
+            settled = true;
+            socket.destroy();
+            if (shouldReject) {
+                reject(new Error("unreachable"));
+            }
+            else {
+                resolve(result);
+            }
+        };
+        socket.once("connect", () => finish(true));
+        socket.once("timeout", () => finish(false, true));
+        socket.once("error", (error) => {
+            if (error.code === "ECONNREFUSED" ||
+                error.code === "EHOSTUNREACH" ||
+                error.code === "ENETUNREACH" ||
+                error.code === "EINVAL") {
+                finish(false, true);
+                return;
+            }
+            finish(false);
+        });
+        socket.setTimeout(150);
+    })))
+        .then((result) => result)
+        .catch(() => false);
+    if (hasActiveListener) {
+        return false;
+    }
     return new Promise((resolve) => {
         const server = createServer();
         server.once("error", (error) => {
@@ -271,11 +477,8 @@ export async function findAvailablePort(startPort) {
  */
 async function ensureD3kSkill(skillsAgentId) {
     try {
-        const bundledSkillsDir = getBundledSkillsPath();
-        if (!bundledSkillsDir)
-            return;
-        const bundledSkillPath = join(bundledSkillsDir, "d3k", "SKILL.md");
-        if (!existsSync(bundledSkillPath))
+        const bundledSkillPath = getBundledD3kSkillPath();
+        if (!bundledSkillPath)
             return;
         const targetSkillsDir = skillsAgentId ? getSkillsPathForLocation(skillsAgentId, "project")?.path : null;
         const skillRoots = new Set();
@@ -327,7 +530,21 @@ async function autoInstallSkills(agentId, debugLog) {
 }
 // REMOVED: cleanup functions are no longer needed
 // CLI integration config files are now kept persistent across dev3000 restarts
-export function createPersistentLogFile() {
+export function createPersistentLogFile(override) {
+    if (override && override.length > 0) {
+        const resolved = resolve(override);
+        const logDir = dirname(resolved);
+        try {
+            if (!existsSync(logDir)) {
+                mkdirSync(logDir, { recursive: true });
+            }
+            appendFileSync(resolved, "");
+            return resolved;
+        }
+        catch (error) {
+            throw new Error(`Failed to initialize --log-file at ${resolved}: ${error instanceof Error ? error.message : String(error)}`);
+        }
+    }
     // Get unique project name
     const projectName = getProjectName();
     // Use ~/.d3k/{projectName}/logs directory for persistent, accessible logs
@@ -358,13 +575,15 @@ export function createPersistentLogFile() {
  * processes belong to THIS d3k instance so we don't accidentally kill
  * Chrome instances from other d3k sessions.
  */
-export function writeSessionInfo(projectName, logFilePath, appPort, publicUrl, cdpUrl, chromePids, serverCommand, framework, serverPid, skillsInstalled, skillsAgentId, preferredBrowserTool) {
+export function writeSessionInfo(projectName, logFilePath, appPort, publicUrl, cdpUrl, chromePids, serverCommand, framework, serverPid, skillsInstalled, skillsAgentId, preferredBrowserTool, agentName) {
     const projectDir = getProjectDir();
     try {
         // Create project directory if it doesn't exist
         if (!existsSync(projectDir)) {
             mkdirSync(projectDir, { recursive: true });
         }
+        const sessionFile = join(projectDir, "session.json");
+        const persistedAgentName = readProjectAgentName();
         // Session file contains project info
         const sessionInfo = {
             projectName,
@@ -381,11 +600,14 @@ export function writeSessionInfo(projectName, logFilePath, appPort, publicUrl, c
             serverPid: serverPid || null,
             skillsInstalled: skillsInstalled || [],
             skillsAgentId: skillsAgentId || null,
-            preferredBrowserTool: preferredBrowserTool || "agent-browser"
+            preferredBrowserTool: preferredBrowserTool || "agent-browser",
+            agentName: agentName || persistedAgentName || null
         };
         // Write session file in project directory
-        const sessionFile = join(projectDir, "session.json");
         writeFileSync(sessionFile, JSON.stringify(sessionInfo, null, 2));
+        if (sessionInfo.agentName) {
+            rememberProjectAgentName(sessionInfo.agentName);
+        }
     }
     catch (error) {
         // Non-fatal - just log a warning
@@ -511,7 +733,7 @@ export class DevEnvironment {
         }
         // Store screenshots in project-specific directory for local access
         const projectName = getProjectName();
-        this.screenshotDir = join(getProjectDir(), "screenshots");
+        this.screenshotDir = options.screenshotsDir ? resolve(options.screenshotsDir) : join(getProjectDir(), "screenshots");
         // Use project-specific PID and lock files to allow multiple projects to run simultaneously
         this.pidFile = join(tmpdir(), `dev3000-${projectName}.pid`);
         this.lockFile = join(tmpdir(), `dev3000-${projectName}.lock`);
@@ -680,10 +902,7 @@ export class DevEnvironment {
         // Best-effort synchronous cleanup (mirrors SIGHUP handler).
         const port = this.options.port;
         this.debugLog(`Synchronous kill for port ${port}`);
-        spawnSync("sh", ["-c", `lsof -ti:${port} | xargs kill -9 2>/dev/null`], {
-            stdio: "pipe",
-            timeout: 5000
-        });
+        killPortProcessesSync(port, this.debugLog.bind(this));
         const projectName = getProjectName();
         const sessionInfo = getSessionInfo(projectName);
         const chromePids = sessionInfo?.chromePids ?? [];
@@ -755,25 +974,7 @@ export class DevEnvironment {
                     // This ensures cleanup happens even if the event loop gets interrupted
                     const port = this.options.port;
                     this.debugLog(`Synchronous kill for port ${port}`);
-                    spawnSync("sh", ["-c", `lsof -ti:${port} | xargs kill -9 2>/dev/null`], {
-                        stdio: "pipe",
-                        timeout: 5000
-                    });
-                    const projectName = getProjectName();
-                    const chromePids = getSessionChromePids(projectName);
-                    if (chromePids.length > 0) {
-                        this.debugLog(`Synchronous kill for Chrome PIDs: [${chromePids.join(", ")}]`);
-                        for (const pid of chromePids) {
-                            try {
-                                process.kill(pid, "SIGTERM");
-                                process.kill(pid, 0);
-                                process.kill(pid, "SIGKILL");
-                            }
-                            catch {
-                                // Ignore - process may already be dead
-                            }
-                        }
-                    }
+                    killPortProcessesSync(port, this.debugLog.bind(this));
                     // Now do the rest of cleanup async
                     this.tui?.updateStatus("Shutting down...");
                     this.handleShutdown()
@@ -942,7 +1143,7 @@ export class DevEnvironment {
             console.log(chalk.cyan(`Logs: ${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: ${this.preferredAppUrl}`));
-            console.log(chalk.cyan(`🔧 CLI Tools: d3k fix, d3k crawl, d3k find-component`));
+            console.log(chalk.cyan(`🔧 CLI Tools: d3k fix, d3k crawl`));
             if (this.options.serversOnly) {
                 console.log(chalk.cyan("🖥️  Servers-only mode - browser monitoring disabled"));
             }
@@ -1189,21 +1390,21 @@ export class DevEnvironment {
             // Check if lock file exists
             if (existsSync(this.lockFile)) {
                 const lockContent = readFileSync(this.lockFile, "utf8");
-                const oldPID = parseInt(lockContent, 10);
-                // Check if the process is still running
-                try {
-                    process.kill(oldPID, 0); // Signal 0 just checks if process exists
-                    // Process is running, lock is valid
+                const validation = validateD3kLockContent(lockContent);
+                if (validation.active) {
+                    this.debugLog(`Lock file is active: ${validation.reason}`);
                     return false;
                 }
-                catch {
-                    // Process doesn't exist, remove stale lock
-                    this.debugLog(`Removing stale lock file for PID ${oldPID}`);
-                    unlinkSync(this.lockFile);
-                }
+                this.debugLog(`Removing stale lock file: ${validation.reason}`);
+                unlinkSync(this.lockFile);
             }
-            // Create lock file with our PID
-            writeFileSync(this.lockFile, process.pid.toString());
+            // Store enough metadata to detect PID reuse after crashes.
+            writeFileSync(this.lockFile, JSON.stringify({
+                pid: process.pid,
+                cwd: process.cwd(),
+                createdAt: new Date().toISOString(),
+                processStartTime: getProcessStartTime(process.pid)
+            }));
             this.debugLog(`Acquired lock file: ${this.lockFile}`);
             return true;
         }
@@ -1247,7 +1448,7 @@ export class DevEnvironment {
         const cdpUrl = this.cdpMonitor?.getCdpUrl() || null;
         const chromePids = this.cdpMonitor?.getChromePids() || [];
         const skillsInstalled = listAvailableSkills(process.cwd());
-        writeSessionInfo(projectName, this.options.logFile, this.options.port, this.publicAppUrl, cdpUrl, chromePids, this.options.serverCommand, this.options.framework, this.serverProcess?.pid, skillsInstalled, this.options.skillsAgentId ?? null, this.options.browserTool);
+        writeSessionInfo(projectName, this.options.logFile, this.options.port, this.publicAppUrl, cdpUrl, chromePids, this.options.serverCommand, this.options.framework, this.serverProcess?.pid, skillsInstalled, this.options.skillsAgentId ?? null, this.options.browserTool, this.options.agentName ?? null);
     }
     detectPortChange(text) {
         // Detect Next.js port switch: "⚠ Port 3000 is in use by process 39543, using available port 3001 instead."
@@ -1561,7 +1762,7 @@ export class DevEnvironment {
         this.cdpMonitor = new CDPMonitor(this.options.profileDir, this.screenshotDir, (_source, message) => {
             this.logger.log("browser", message);
         }, this.options.debug, this.options.browser, this.options.pluginReactScan, this.options.port, // App server port to monitor
-        this.preferredAppUrl, this.options.debugPort, // Chrome debug port
+        this.preferredAppUrl, this.options.browserNavigationTimeoutSeconds * 1000, this.options.debugPort, // Chrome debug port
         this.options.headless, // Headless mode for serverless/CI environments
         this.options.framework // Framework hint for optional React DevTools launch args
         );
@@ -1594,9 +1795,7 @@ export class DevEnvironment {
             this.writeCurrentSessionInfo(projectName);
             this.debugLog(`Updated session info with CDP URL: ${cdpUrl}, Chrome PIDs: [${chromePids.join(", ")}]`);
             this.logger.log("browser", `[CDP] Session info written with cdpUrl: ${cdpUrl ? "available" : "null"}`);
-            // Navigate to the app
-            await this.cdpMonitor.navigateToUrl(this.preferredAppUrl);
-            this.logger.log("browser", `[CDP] Navigated to ${this.preferredAppUrl}`);
+            this.logger.log("browser", `[CDP] Loading page will hand off to ${this.preferredAppUrl}`);
         }
         catch (error) {
             // Log error and throw to trigger graceful shutdown
@@ -1664,7 +1863,7 @@ export class DevEnvironment {
                 console.log(chalk.gray(`ℹ️ Skipping ${name} port kill in sandbox environment`));
                 return;
             }
-            if (!/^\d+$/.test(port)) {
+            if (parsePortNumber(port) === null) {
                 this.debugLog(`Skipping ${name} port kill for invalid port: ${port}`);
                 return;
             }
@@ -1704,23 +1903,27 @@ export class DevEnvironment {
         // Kill app server only
         console.log(chalk.cyan("🔄 Killing app server..."));
         await killPortProcess(this.options.port, "your app server");
-        // Kill server process and its children using the saved PID (from before session file was deleted)
-        if (sessionInfo?.serverPid) {
-            this.killServerPidIfOwned(sessionInfo.serverPid, sessionInfo.cwd, "graceful shutdown");
-        }
-        // Always kill tracked Chrome processes, even if cdpMonitor is unavailable.
-        this.killTrackedChromePids(sessionInfo?.chromePids ?? [], "graceful shutdown");
         // Shutdown CDP monitor if it was started
+        let chromeShutdownHandled = false;
         if (this.cdpMonitor) {
             try {
                 console.log(chalk.cyan("🔄 Closing CDP monitor..."));
                 await this.cdpMonitor.shutdown();
+                chromeShutdownHandled = true;
                 console.log(chalk.green("✅ CDP monitor closed"));
             }
             catch (_error) {
                 console.log(chalk.gray("⚠️ CDP monitor shutdown failed"));
             }
         }
+        if (!chromeShutdownHandled) {
+            // Safety net when CDP was unavailable: terminate only Chrome processes from this d3k session.
+            this.killTrackedChromePids(sessionInfo?.chromePids ?? [], "graceful shutdown");
+        }
+        // Kill server process and its children using the saved PID (from before session file was deleted)
+        if (sessionInfo?.serverPid) {
+            this.killServerPidIfOwned(sessionInfo.serverPid, sessionInfo.cwd, "graceful shutdown");
+        }
         console.log(chalk.red(`❌ ${this.options.commandName} exited due to server failure`));
         // Show recent log entries to help diagnose the issue
         this.showRecentLogs();
@@ -1761,26 +1964,9 @@ export class DevEnvironment {
             // This ensures cleanup happens even if the event loop gets interrupted
             const port = this.options.port;
             this.debugLog(`Synchronous kill for port ${port}`);
-            spawnSync("sh", ["-c", `lsof -ti:${port} | xargs kill -9 2>/dev/null`], {
-                stdio: "pipe",
-                timeout: 5000
-            });
+            killPortProcessesSync(port, this.debugLog.bind(this));
             const projectName = getProjectName();
             const sessionInfo = getSessionInfo(projectName);
-            const chromePids = sessionInfo?.chromePids ?? [];
-            if (chromePids.length > 0) {
-                this.debugLog(`Synchronous kill for Chrome PIDs: [${chromePids.join(", ")}]`);
-                for (const pid of chromePids) {
-                    try {
-                        process.kill(pid, "SIGTERM");
-                        process.kill(pid, 0);
-                        process.kill(pid, "SIGKILL");
-                    }
-                    catch {
-                        // Ignore - process may already be dead
-                    }
-                }
-            }
             if (sessionInfo?.serverPid) {
                 this.killServerPidIfOwned(sessionInfo.serverPid, sessionInfo.cwd, "SIGINT");
             }
@@ -1793,7 +1979,7 @@ export class DevEnvironment {
             const forceExitTimeout = setTimeout(() => {
                 this.debugLog("Shutdown timeout reached, forcing exit");
                 process.exit(1);
-            }, 5000); // 5 second timeout
+            }, 10000); // Give Chrome enough time to record a clean profile exit.
             // Call async cleanup in a non-blocking way
             this.handleShutdown()
                 .then(() => {
@@ -1820,26 +2006,9 @@ export class DevEnvironment {
             // CRITICAL: Kill port processes SYNCHRONOUSLY first, before anything else
             const port = this.options.port;
             this.debugLog(`Synchronous kill for port ${port}`);
-            spawnSync("sh", ["-c", `lsof -ti:${port} | xargs kill -9 2>/dev/null`], {
-                stdio: "pipe",
-                timeout: 5000
-            });
+            killPortProcessesSync(port, this.debugLog.bind(this));
             const projectName = getProjectName();
             const sessionInfo = getSessionInfo(projectName);
-            const chromePids = sessionInfo?.chromePids ?? [];
-            if (chromePids.length > 0) {
-                this.debugLog(`Synchronous kill for Chrome PIDs: [${chromePids.join(", ")}]`);
-                for (const pid of chromePids) {
-                    try {
-                        process.kill(pid, "SIGTERM");
-                        process.kill(pid, 0);
-                        process.kill(pid, "SIGKILL");
-                    }
-                    catch {
-                        // Ignore - process may already be dead
-                    }
-                }
-            }
             if (sessionInfo?.serverPid) {
                 this.killServerPidIfOwned(sessionInfo.serverPid, sessionInfo.cwd, "SIGTERM");
             }
@@ -1932,12 +2101,14 @@ export class DevEnvironment {
             console.log(chalk.yellow("\n🛑 Received interrupt signal. Cleaning up processes..."));
         }
         // Shutdown CDP monitor FIRST - this should close Chrome
+        let chromeShutdownHandled = false;
         if (this.cdpMonitor) {
             try {
                 if (!this.options.tui) {
                     console.log(chalk.cyan("🔄 Closing Chrome browser..."));
                 }
                 await this.cdpMonitor.shutdown();
+                chromeShutdownHandled = true;
                 if (!this.options.tui) {
                     console.log(chalk.green("✅ Chrome browser closed"));
                 }
@@ -1973,8 +2144,10 @@ export class DevEnvironment {
                 }
             }
         }
-        // Safety net: ensure tracked Chrome processes are always terminated on shutdown.
-        this.killTrackedChromePids(sessionInfo?.chromePids ?? [], "handleShutdown");
+        if (!chromeShutdownHandled) {
+            // Safety net: ensure tracked Chrome processes are always terminated on shutdown.
+            this.killTrackedChromePids(sessionInfo?.chromePids ?? [], "handleShutdown");
+        }
         // REMOVED: No longer clean up CLI config files on shutdown
         // This was causing Claude Code instances to crash when dev3000 was killed
         // Config file cleanup removed; keep user config files untouched on shutdown
@@ -1985,7 +2158,7 @@ export class DevEnvironment {
                 this.debugLog(`Skipping ${name} port kill in sandbox environment`);
                 return;
             }
-            if (!/^\d+$/.test(port)) {
+            if (parsePortNumber(port) === null) {
                 this.debugLog(`Skipping ${name} port kill for invalid port: ${port}`);
                 return;
             }
@@ -2046,12 +2219,7 @@ export class DevEnvironment {
         // Primary: Synchronous kill - most reliable, ensures completion
         // NOTE: We always try this, even if lsof might not exist - errors are caught
         try {
-            const { spawnSync } = await import("child_process");
-            const result = spawnSync("sh", ["-c", `lsof -ti:${this.options.port} | xargs kill -9 2>/dev/null`], {
-                stdio: "pipe",
-                timeout: 5000
-            });
-            this.debugLog(`Synchronous kill for port ${this.options.port} exit code: ${result.status}`);
+            killPortProcessesSync(this.options.port, this.debugLog.bind(this));
         }
         catch (error) {
             this.debugLog(`Synchronous kill error: ${error}`);
@@ -2080,25 +2248,24 @@ export class DevEnvironment {
         await killPortProcess(this.options.port, "your app server");
         // Double-check: try to kill any remaining processes on the app port
         try {
-            const { spawnSync } = await import("child_process");
-            // Kill by port pattern
-            spawnSync("sh", ["-c", `pkill -f ":${this.options.port}"`], { stdio: "ignore" });
-            this.debugLog(`Sent pkill signal for port ${this.options.port}`);
+            const parsedPort = parsePortNumber(this.options.port);
+            if (parsedPort !== null) {
+                pkillByPattern(`:${parsedPort}`, this.debugLog.bind(this));
+                this.debugLog(`Sent pkill signal for port ${parsedPort}`);
+            }
             // Specifically kill any remaining next dev processes in the current directory
             // This catches cases where the shell wrapper exited but next-server survived
             const cwd = process.cwd();
-            spawnSync("sh", ["-c", `pkill -f "next dev.*${cwd}"`], { stdio: "ignore" });
-            spawnSync("sh", ["-c", `pkill -f "next-server.*${cwd}"`], { stdio: "ignore" });
+            const escapedCwd = escapeRegexForPkill(cwd);
+            pkillByPattern(`next dev.*${escapedCwd}`, this.debugLog.bind(this));
+            pkillByPattern(`next-server.*${escapedCwd}`, this.debugLog.bind(this));
             this.debugLog(`Sent pkill signal for next processes in ${cwd}`);
             // Kill server process and its children using the saved PID (from before session file was deleted)
             if (sessionInfo?.serverPid) {
                 this.killServerPidIfOwned(sessionInfo.serverPid, sessionInfo.cwd, "handleShutdown");
             }
             // Final synchronous lsof kill - most reliable method
-            const result = spawnSync("sh", ["-c", `lsof -ti:${this.options.port} | xargs kill -9 2>/dev/null`], {
-                stdio: "pipe"
-            });
-            this.debugLog(`Final lsof kill exit code: ${result.status}`);
+            killPortProcessesSync(this.options.port, this.debugLog.bind(this));
         }
         catch {
             // Ignore pkill errors