dev3000 0.0.171 → 0.0.174

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";
@@ -14,6 +14,7 @@ import { ScreencastManager } from "./screencast-manager.js";
 import { NextJsErrorDetector, OutputProcessor, StandardLogParser } from "./services/parsers/index.js";
 import { getBundledSkillsPath, 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";
@@ -163,6 +164,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 +282,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) => {
@@ -358,13 +502,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) {
+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,
@@ -380,11 +526,15 @@ export function writeSessionInfo(projectName, logFilePath, appPort, publicUrl, c
             framework: framework || null,
             serverPid: serverPid || null,
             skillsInstalled: skillsInstalled || [],
-            skillsAgentId: skillsAgentId || null
+            skillsAgentId: skillsAgentId || null,
+            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
@@ -1188,21 +1338,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;
         }
@@ -1246,7 +1396,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);
+        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."
@@ -1560,7 +1710,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
         );
@@ -1593,9 +1743,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
@@ -1931,12 +2079,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"));
                 }
@@ -1972,8 +2122,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