buncargo 1.0.11 → 1.0.13

package/core/process.ts

@@ -4,6 +4,7 @@ import {
 	type SpawnOptions,
 	spawn,
 } from "node:child_process";
+import { platform } from "node:os";
 import { resolve } from "node:path";
 import type { AppConfig, DevServerPids, ExecOptions } from "../types";
 
@@ -93,19 +94,41 @@ export interface SpawnDevServerOptions {
 	verbose?: boolean;
 	detached?: boolean;
 	isCI?: boolean;
+	/** Kill any existing process using the port before starting. Default: true */
+	killExisting?: boolean;
+	/** The port this server will use (required if killExisting is true) */
+	port?: number;
 }
 
 /**
  * Spawn a dev server as a detached process.
+ * If killExisting is true and port is provided, kills any existing process on that port first.
  */
-export function spawnDevServer(
+export async function spawnDevServer(
 	command: string,
 	root: string,
 	appCwd: string | undefined,
 	envVars: Record<string, string>,
 	options: SpawnDevServerOptions = {},
-): ChildProcess {
-	const { verbose = false, detached = true, isCI = false } = options;
+): Promise<ChildProcess> {
+	const {
+		verbose = false,
+		detached = true,
+		isCI = false,
+		killExisting = true,
+		port,
+	} = options;
+
+	// Kill existing process on the port if requested
+	if (killExisting && port !== undefined) {
+		const existingPid = getProcessOnPort(port);
+		if (existingPid !== null) {
+			if (verbose) {
+				console.log(`   ⚠️  Port ${port} is in use by process ${existingPid}`);
+			}
+			await killProcessOnPortAndWait(port, { verbose });
+		}
+	}
 
 	// Parse command into parts
 	const parts = command.split(" ");
@@ -134,20 +157,31 @@ export function spawnDevServer(
 	return proc;
 }
 
+export interface StartDevServersOptions {
+	verbose?: boolean;
+	productionBuild?: boolean;
+	isCI?: boolean;
+	/** Kill any existing process using the port before starting. Default: true */
+	killExisting?: boolean;
+}
+
 /**
  * Start all configured dev servers.
+ * If killExisting is true (default), any process already using a port will be killed first.
  */
-export function startDevServers(
+export async function startDevServers(
 	apps: Record<string, AppConfig>,
 	root: string,
 	envVars: Record<string, string>,
-	options: {
-		verbose?: boolean;
-		productionBuild?: boolean;
-		isCI?: boolean;
-	} = {},
-): DevServerPids {
-	const { verbose = true, productionBuild = false, isCI = false } = options;
+	ports: Record<string, number>,
+	options: StartDevServersOptions = {},
+): Promise<DevServerPids> {
+	const {
+		verbose = true,
+		productionBuild = false,
+		isCI = false,
+		killExisting = true,
+	} = options;
 	const pids: DevServerPids = {};
 
 	if (verbose) {
@@ -163,9 +197,13 @@ export function startDevServers(
 			? (config.prodCommand ?? config.devCommand)
 			: config.devCommand;
 
-		const proc = spawnDevServer(command, root, config.cwd, envVars, {
+		const port = ports[name];
+
+		const proc = await spawnDevServer(command, root, config.cwd, envVars, {
 			verbose,
 			isCI,
+			killExisting,
+			port,
 		});
 
 		if (proc.pid) {
@@ -179,6 +217,158 @@ export function startDevServers(
 	return pids;
 }
 
+// ═══════════════════════════════════════════════════════════════════════════
+// Port Process Management
+// ═══════════════════════════════════════════════════════════════════════════
+
+/**
+ * Get the PID of the process using a specific port.
+ * Returns null if no process is using the port.
+ */
+export function getProcessOnPort(port: number): number | null {
+	try {
+		const os = platform();
+		let output: string;
+
+		if (os === "win32") {
+			// Windows: use netstat
+			output = execSync(`netstat -ano | findstr :${port}`, {
+				encoding: "utf-8",
+				stdio: ["pipe", "pipe", "pipe"],
+			});
+			// Parse Windows netstat output: TCP 0.0.0.0:3000 0.0.0.0:0 LISTENING 12345
+			const lines = output.trim().split("\n");
+			for (const line of lines) {
+				// Only match LISTENING state
+				if (line.includes("LISTENING")) {
+					const parts = line.trim().split(/\s+/);
+					const pid = Number.parseInt(parts[parts.length - 1], 10);
+					if (!Number.isNaN(pid) && pid > 0) {
+						return pid;
+					}
+				}
+			}
+		} else {
+			// macOS/Linux: use lsof
+			output = execSync(`lsof -ti :${port}`, {
+				encoding: "utf-8",
+				stdio: ["pipe", "pipe", "pipe"],
+			});
+			const pid = Number.parseInt(output.trim().split("\n")[0], 10);
+			if (!Number.isNaN(pid) && pid > 0) {
+				return pid;
+			}
+		}
+
+		return null;
+	} catch {
+		// No process found on port (command exits with error)
+		return null;
+	}
+}
+
+/**
+ * Check if a port is currently in use.
+ */
+export function isPortInUse(port: number): boolean {
+	return getProcessOnPort(port) !== null;
+}
+
+/**
+ * Kill the process using a specific port.
+ * Returns true if a process was killed, false if no process was using the port.
+ */
+export function killProcessOnPort(
+	port: number,
+	options: { verbose?: boolean; signal?: NodeJS.Signals } = {},
+): boolean {
+	const { verbose = false, signal = "SIGTERM" } = options;
+
+	const pid = getProcessOnPort(port);
+	if (pid === null) {
+		return false;
+	}
+
+	try {
+		if (verbose) {
+			console.log(`   Killing process ${pid} on port ${port}`);
+		}
+		process.kill(pid, signal);
+		return true;
+	} catch {
+		// Process may have already exited
+		return false;
+	}
+}
+
+/**
+ * Kill the process on port and wait for it to fully release the port.
+ * Uses SIGTERM first, then SIGKILL if the process doesn't exit.
+ */
+export async function killProcessOnPortAndWait(
+	port: number,
+	options: { verbose?: boolean; timeout?: number } = {},
+): Promise<boolean> {
+	const { verbose = false, timeout = 5000 } = options;
+
+	const pid = getProcessOnPort(port);
+	if (pid === null) {
+		return false;
+	}
+
+	if (verbose) {
+		console.log(`   Killing process ${pid} on port ${port}...`);
+	}
+
+	// First try SIGTERM
+	try {
+		process.kill(pid, "SIGTERM");
+	} catch {
+		// Process may have already exited
+		return false;
+	}
+
+	// Wait for port to be released
+	const startTime = Date.now();
+	const checkInterval = 100;
+
+	while (Date.now() - startTime < timeout) {
+		await new Promise((resolve) => setTimeout(resolve, checkInterval));
+
+		if (!isPortInUse(port)) {
+			if (verbose) {
+				console.log(`   ✓ Port ${port} released`);
+			}
+			return true;
+		}
+	}
+
+	// If still running, try SIGKILL
+	if (verbose) {
+		console.log(`   Process ${pid} didn't exit, sending SIGKILL...`);
+	}
+
+	try {
+		process.kill(pid, "SIGKILL");
+	} catch {
+		// Process may have already exited
+	}
+
+	// Wait a bit more for SIGKILL
+	await new Promise((resolve) => setTimeout(resolve, 500));
+
+	const released = !isPortInUse(port);
+	if (verbose) {
+		if (released) {
+			console.log(`   ✓ Port ${port} released after SIGKILL`);
+		} else {
+			console.log(`   ⚠ Port ${port} still in use`);
+		}
+	}
+
+	return released;
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Process Management
 // ═══════════════════════════════════════════════════════════════════════════

package/dist/bin.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env bun
 import {
   runCli
-} from "./index-twc5zwja.js";
+} from "./index-6srpc523.js";
 import {
   loadDevEnv
-} from "./index-habjkmf5.js";
-import"./index-hb4y6f08.js";
-import"./index-8gd8fkwx.js";
-import"./index-6qd90dkp.js";
+} from "./index-75y4cg2z.js";
+import"./index-ndnmnsej.js";
+import"./index-vhs88xhe.js";
+import"./index-cty0bcry.js";
 import"./index-tjqw9vtj.js";
 import"./index-5hka0tff.js";
 import"./index-2fr3g85b.js";
@@ -21,7 +21,7 @@ import {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "buncargo",
-    version: "1.0.11",
+    version: "1.0.13",
     description: "A Bun-powered development environment CLI for managing Docker Compose services, dev servers, and environment variables",
     type: "module",
     module: "./dist/index.js",

package/dist/cli.js

@@ -2,9 +2,9 @@ import {
   getFlagValue,
   hasFlag,
   runCli
-} from "./index-twc5zwja.js";
-import"./index-8gd8fkwx.js";
-import"./index-6qd90dkp.js";
+} from "./index-6srpc523.js";
+import"./index-vhs88xhe.js";
+import"./index-cty0bcry.js";
 import"./index-qnx9j3qa.js";
 export {
   runCli,

package/dist/core/index.js

@@ -9,17 +9,21 @@ import {
   startHeartbeat,
   stopHeartbeat,
   stopWatchdog
-} from "../index-8gd8fkwx.js";
+} from "../index-vhs88xhe.js";
 import {
   buildApps,
   exec,
   execAsync,
+  getProcessOnPort,
+  isPortInUse,
   isProcessAlive,
+  killProcessOnPort,
+  killProcessOnPortAndWait,
   spawnDevServer,
   startDevServers,
   stopAllProcesses,
   stopProcess
-} from "../index-6qd90dkp.js";
+} from "../index-cty0bcry.js";
 import {
   MAX_ATTEMPTS,
   POLL_INTERVAL,
@@ -78,9 +82,12 @@ export {
   logFrontendPort,
   logExpoApiUrl,
   logApiUrl,
+  killProcessOnPortAndWait,
+  killProcessOnPort,
   isWorktree,
   isWatchdogRunning,
   isProcessAlive,
+  isPortInUse,
   isPortAvailable,
   isContainerRunning,
   isCI,
@@ -88,6 +95,7 @@ export {
   getWatchdogPidFile,
   getWatchdogPid,
   getProjectName,
+  getProcessOnPort,
   getLocalIp,
   getHeartbeatFile,
   getEnvVar,

package/dist/core/process.d.ts

@@ -17,19 +17,53 @@ export interface SpawnDevServerOptions {
     verbose?: boolean;
     detached?: boolean;
     isCI?: boolean;
+    /** Kill any existing process using the port before starting. Default: true */
+    killExisting?: boolean;
+    /** The port this server will use (required if killExisting is true) */
+    port?: number;
 }
 /**
  * Spawn a dev server as a detached process.
+ * If killExisting is true and port is provided, kills any existing process on that port first.
  */
-export declare function spawnDevServer(command: string, root: string, appCwd: string | undefined, envVars: Record<string, string>, options?: SpawnDevServerOptions): ChildProcess;
+export declare function spawnDevServer(command: string, root: string, appCwd: string | undefined, envVars: Record<string, string>, options?: SpawnDevServerOptions): Promise<ChildProcess>;
+export interface StartDevServersOptions {
+    verbose?: boolean;
+    productionBuild?: boolean;
+    isCI?: boolean;
+    /** Kill any existing process using the port before starting. Default: true */
+    killExisting?: boolean;
+}
 /**
  * Start all configured dev servers.
+ * If killExisting is true (default), any process already using a port will be killed first.
+ */
+export declare function startDevServers(apps: Record<string, AppConfig>, root: string, envVars: Record<string, string>, ports: Record<string, number>, options?: StartDevServersOptions): Promise<DevServerPids>;
+/**
+ * Get the PID of the process using a specific port.
+ * Returns null if no process is using the port.
+ */
+export declare function getProcessOnPort(port: number): number | null;
+/**
+ * Check if a port is currently in use.
  */
-export declare function startDevServers(apps: Record<string, AppConfig>, root: string, envVars: Record<string, string>, options?: {
+export declare function isPortInUse(port: number): boolean;
+/**
+ * Kill the process using a specific port.
+ * Returns true if a process was killed, false if no process was using the port.
+ */
+export declare function killProcessOnPort(port: number, options?: {
     verbose?: boolean;
-    productionBuild?: boolean;
-    isCI?: boolean;
-}): DevServerPids;
+    signal?: NodeJS.Signals;
+}): boolean;
+/**
+ * Kill the process on port and wait for it to fully release the port.
+ * Uses SIGTERM first, then SIGKILL if the process doesn't exit.
+ */
+export declare function killProcessOnPortAndWait(port: number, options?: {
+    verbose?: boolean;
+    timeout?: number;
+}): Promise<boolean>;
 /**
  * Stop a process by PID.
  */

package/dist/core/process.js

@@ -2,19 +2,27 @@ import {
   buildApps,
   exec,
   execAsync,
+  getProcessOnPort,
+  isPortInUse,
   isProcessAlive,
+  killProcessOnPort,
+  killProcessOnPortAndWait,
   spawnDevServer,
   startDevServers,
   stopAllProcesses,
   stopProcess
-} from "../index-6qd90dkp.js";
+} from "../index-cty0bcry.js";
 import"../index-qnx9j3qa.js";
 export {
   stopProcess,
   stopAllProcesses,
   startDevServers,
   spawnDevServer,
+  killProcessOnPortAndWait,
+  killProcessOnPort,
   isProcessAlive,
+  isPortInUse,
+  getProcessOnPort,
   execAsync,
   exec,
   buildApps

package/dist/core/watchdog.js

@@ -9,8 +9,8 @@ import {
   startHeartbeat,
   stopHeartbeat,
   stopWatchdog
-} from "../index-8gd8fkwx.js";
-import"../index-6qd90dkp.js";
+} from "../index-vhs88xhe.js";
+import"../index-cty0bcry.js";
 import"../index-qnx9j3qa.js";
 export {
   stopWatchdog,

package/dist/environment.js

@@ -1,8 +1,8 @@
 import {
   createDevEnvironment
-} from "./index-hb4y6f08.js";
-import"./index-8gd8fkwx.js";
-import"./index-6qd90dkp.js";
+} from "./index-ndnmnsej.js";
+import"./index-vhs88xhe.js";
+import"./index-cty0bcry.js";
 import"./index-tjqw9vtj.js";
 import"./index-5hka0tff.js";
 import"./index-2fr3g85b.js";