buncargo 1.0.15 → 1.0.17

package/cli.ts

@@ -1,4 +1,5 @@
 import { spawn } from "node:child_process";
+import { killProcessesOnAppPorts } from "./core/process";
 import { spawnWatchdog, startHeartbeat, stopHeartbeat } from "./core/watchdog";
 import type {
 	AppConfig,
@@ -109,6 +110,9 @@ export async function runCli<
 		return;
 	}
 
+	// Kill any existing processes on app ports before starting
+	await killProcessesOnAppPorts(env.apps, env.ports);
+
 	// Start dev servers interactively
 	console.log("");
 	console.log("🔧 Starting dev servers...");

package/core/process.ts

@@ -369,6 +369,42 @@ export async function killProcessOnPortAndWait(
 	return released;
 }
 
+/**
+ * Kill any existing processes using the specified app ports.
+ * Used before starting dev servers to ensure ports are available.
+ */
+export async function killProcessesOnAppPorts(
+	apps: Record<string, AppConfig>,
+	ports: Record<string, number>,
+	options: { verbose?: boolean } = {},
+): Promise<void> {
+	const { verbose = true } = options;
+	const appNames = Object.keys(apps);
+	if (appNames.length === 0) return;
+
+	let killedAny = false;
+
+	for (const name of appNames) {
+		const port = ports[name];
+		if (port === undefined) continue;
+
+		const existingPid = getProcessOnPort(port);
+		if (existingPid !== null) {
+			if (!killedAny && verbose) {
+				console.log("");
+				killedAny = true;
+			}
+			if (verbose) {
+				console.log(`⚠️  Port ${port} (${name}) is in use by process ${existingPid}`);
+			}
+			const killed = await killProcessOnPortAndWait(port, { verbose });
+			if (!killed && verbose) {
+				console.log(`   ⚠️  Could not kill process on port ${port}, server may fail to start`);
+			}
+		}
+	}
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Process Management
 // ═══════════════════════════════════════════════════════════════════════════

package/dist/bin.js

@@ -1,13 +1,13 @@
 #!/usr/bin/env bun
 import {
   runCli
-} from "./index-g6eb5wdw.js";
+} from "./index-8hbbj1mp.js";
 import {
   loadDevEnv
-} from "./index-75y4cg2z.js";
-import"./index-ndnmnsej.js";
-import"./index-vhs88xhe.js";
-import"./index-cty0bcry.js";
+} from "./index-qw4093g2.js";
+import"./index-2f47khe5.js";
+import"./index-ggq3yryx.js";
+import"./index-1yvbwj4k.js";
 import"./index-tjqw9vtj.js";
 import"./index-5hka0tff.js";
 import"./index-2fr3g85b.js";
@@ -22,7 +22,7 @@ import {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "buncargo",
-    version: "1.0.15",
+    version: "1.0.17",
     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-g6eb5wdw.js";
-import"./index-vhs88xhe.js";
-import"./index-cty0bcry.js";
+} from "./index-8hbbj1mp.js";
+import"./index-ggq3yryx.js";
+import"./index-1yvbwj4k.js";
 import"./index-qnx9j3qa.js";
 export {
   runCli,

package/dist/core/index.js

@@ -9,7 +9,7 @@ import {
   startHeartbeat,
   stopHeartbeat,
   stopWatchdog
-} from "../index-vhs88xhe.js";
+} from "../index-ggq3yryx.js";
 import {
   buildApps,
   exec,
@@ -19,11 +19,12 @@ import {
   isProcessAlive,
   killProcessOnPort,
   killProcessOnPortAndWait,
+  killProcessesOnAppPorts,
   spawnDevServer,
   startDevServers,
   stopAllProcesses,
   stopProcess
-} from "../index-cty0bcry.js";
+} from "../index-1yvbwj4k.js";
 import {
   MAX_ATTEMPTS,
   POLL_INTERVAL,
@@ -82,6 +83,7 @@ export {
   logFrontendPort,
   logExpoApiUrl,
   logApiUrl,
+  killProcessesOnAppPorts,
   killProcessOnPortAndWait,
   killProcessOnPort,
   isWorktree,

package/dist/core/process.d.ts

@@ -64,6 +64,13 @@ export declare function killProcessOnPortAndWait(port: number, options?: {
     verbose?: boolean;
     timeout?: number;
 }): Promise<boolean>;
+/**
+ * Kill any existing processes using the specified app ports.
+ * Used before starting dev servers to ensure ports are available.
+ */
+export declare function killProcessesOnAppPorts(apps: Record<string, AppConfig>, ports: Record<string, number>, options?: {
+    verbose?: boolean;
+}): Promise<void>;
 /**
  * Stop a process by PID.
  */

package/dist/core/process.js

@@ -7,17 +7,19 @@ import {
   isProcessAlive,
   killProcessOnPort,
   killProcessOnPortAndWait,
+  killProcessesOnAppPorts,
   spawnDevServer,
   startDevServers,
   stopAllProcesses,
   stopProcess
-} from "../index-cty0bcry.js";
+} from "../index-1yvbwj4k.js";
 import"../index-qnx9j3qa.js";
 export {
   stopProcess,
   stopAllProcesses,
   startDevServers,
   spawnDevServer,
+  killProcessesOnAppPorts,
   killProcessOnPortAndWait,
   killProcessOnPort,
   isProcessAlive,

package/dist/core/watchdog.js

@@ -9,8 +9,8 @@ import {
   startHeartbeat,
   stopHeartbeat,
   stopWatchdog
-} from "../index-vhs88xhe.js";
-import"../index-cty0bcry.js";
+} from "../index-ggq3yryx.js";
+import"../index-1yvbwj4k.js";
 import"../index-qnx9j3qa.js";
 export {
   stopWatchdog,

package/dist/environment.js

@@ -1,8 +1,8 @@
 import {
   createDevEnvironment
-} from "./index-ndnmnsej.js";
-import"./index-vhs88xhe.js";
-import"./index-cty0bcry.js";
+} from "./index-2f47khe5.js";
+import"./index-ggq3yryx.js";
+import"./index-1yvbwj4k.js";
 import"./index-tjqw9vtj.js";
 import"./index-5hka0tff.js";
 import"./index-2fr3g85b.js";

package/dist/index-1yvbwj4k.js

@@ -0,0 +1,274 @@
+// core/process.ts
+import {
+  execSync,
+  spawn
+} from "node:child_process";
+import { platform } from "node:os";
+import { resolve } from "node:path";
+function exec(cmd, root, envVars, options = {}) {
+  const { cwd, verbose = false, env = {}, throwOnError = true } = options;
+  const workingDir = cwd ? resolve(root, cwd) : root;
+  const fullEnv = { ...process.env, ...envVars, ...env };
+  try {
+    const stdout = execSync(cmd, {
+      cwd: workingDir,
+      env: fullEnv,
+      encoding: "utf-8",
+      stdio: verbose ? "inherit" : ["pipe", "pipe", "pipe"]
+    });
+    return {
+      exitCode: 0,
+      stdout: typeof stdout === "string" ? stdout : "",
+      stderr: ""
+    };
+  } catch (error) {
+    const execError = error;
+    const result = {
+      exitCode: execError.status ?? 1,
+      stdout: execError.stdout ?? "",
+      stderr: execError.stderr ?? ""
+    };
+    if (throwOnError) {
+      throw new Error(`Command failed with exit code ${result.exitCode}: ${cmd}
+${result.stderr}`);
+    }
+    return result;
+  }
+}
+async function execAsync(cmd, root, envVars, options = {}) {
+  return new Promise((resolve2) => {
+    const result = exec(cmd, root, envVars, {
+      ...options,
+      throwOnError: false
+    });
+    resolve2(result);
+  });
+}
+async function spawnDevServer(command, root, appCwd, envVars, options = {}) {
+  const {
+    verbose = false,
+    detached = true,
+    isCI = false,
+    killExisting = true,
+    port
+  } = options;
+  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 });
+    }
+  }
+  const parts = command.split(" ");
+  const cmd = parts[0];
+  const args = parts.slice(1);
+  if (!cmd) {
+    throw new Error("Command cannot be empty");
+  }
+  const workingDir = appCwd ? resolve(root, appCwd) : root;
+  const spawnOptions = {
+    cwd: workingDir,
+    env: { ...process.env, ...envVars },
+    detached,
+    stdio: isCI || verbose ? "inherit" : "ignore"
+  };
+  const proc = spawn(cmd, args, spawnOptions);
+  if (detached && proc.unref) {
+    proc.unref();
+  }
+  return proc;
+}
+async function startDevServers(apps, root, envVars, ports, options = {}) {
+  const {
+    verbose = true,
+    productionBuild = false,
+    isCI = false,
+    killExisting = true
+  } = options;
+  const pids = {};
+  if (verbose) {
+    console.log(productionBuild ? "\uD83D\uDE80 Starting production servers..." : "\uD83D\uDD27 Starting dev servers...");
+  }
+  for (const [name, config] of Object.entries(apps)) {
+    const command = productionBuild ? config.prodCommand ?? config.devCommand : config.devCommand;
+    const port = ports[name];
+    const proc = await spawnDevServer(command, root, config.cwd, envVars, {
+      verbose,
+      isCI,
+      killExisting,
+      port
+    });
+    if (proc.pid) {
+      pids[name] = proc.pid;
+      if (verbose) {
+        console.log(`   ${name} PID: ${proc.pid}`);
+      }
+    }
+  }
+  return pids;
+}
+function getProcessOnPort(port) {
+  try {
+    const os = platform();
+    let output;
+    if (os === "win32") {
+      output = execSync(`netstat -ano | findstr :${port}`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const lines = output.trim().split(`
+`);
+      for (const line of lines) {
+        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 {
+      output = execSync(`lsof -ti :${port}`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+      const pid = Number.parseInt(output.trim().split(`
+`)[0], 10);
+      if (!Number.isNaN(pid) && pid > 0) {
+        return pid;
+      }
+    }
+    return null;
+  } catch {
+    return null;
+  }
+}
+function isPortInUse(port) {
+  return getProcessOnPort(port) !== null;
+}
+function killProcessOnPort(port, options = {}) {
+  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 {
+    return false;
+  }
+}
+async function killProcessOnPortAndWait(port, options = {}) {
+  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}...`);
+  }
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    return false;
+  }
+  const startTime = Date.now();
+  const checkInterval = 100;
+  while (Date.now() - startTime < timeout) {
+    await new Promise((resolve2) => setTimeout(resolve2, checkInterval));
+    if (!isPortInUse(port)) {
+      if (verbose) {
+        console.log(`   ✓ Port ${port} released`);
+      }
+      return true;
+    }
+  }
+  if (verbose) {
+    console.log(`   Process ${pid} didn't exit, sending SIGKILL...`);
+  }
+  try {
+    process.kill(pid, "SIGKILL");
+  } catch {}
+  await new Promise((resolve2) => setTimeout(resolve2, 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;
+}
+async function killProcessesOnAppPorts(apps, ports, options = {}) {
+  const { verbose = true } = options;
+  const appNames = Object.keys(apps);
+  if (appNames.length === 0)
+    return;
+  let killedAny = false;
+  for (const name of appNames) {
+    const port = ports[name];
+    if (port === undefined)
+      continue;
+    const existingPid = getProcessOnPort(port);
+    if (existingPid !== null) {
+      if (!killedAny && verbose) {
+        console.log("");
+        killedAny = true;
+      }
+      if (verbose) {
+        console.log(`⚠️  Port ${port} (${name}) is in use by process ${existingPid}`);
+      }
+      const killed = await killProcessOnPortAndWait(port, { verbose });
+      if (!killed && verbose) {
+        console.log(`   ⚠️  Could not kill process on port ${port}, server may fail to start`);
+      }
+    }
+  }
+}
+function stopProcess(pid) {
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {}
+}
+function stopAllProcesses(pids, options = {}) {
+  const { verbose = true } = options;
+  for (const [name, pid] of Object.entries(pids)) {
+    if (pid) {
+      if (verbose)
+        console.log(`   Stopping ${name} (PID: ${pid})`);
+      stopProcess(pid);
+    }
+  }
+}
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function buildApps(apps, root, envVars, options = {}) {
+  const { verbose = true } = options;
+  for (const [name, config] of Object.entries(apps)) {
+    if (config.buildCommand) {
+      if (verbose)
+        console.log(`\uD83D\uDD28 Building ${name}...`);
+      exec(config.buildCommand, root, envVars, {
+        cwd: config.cwd,
+        verbose
+      });
+    }
+  }
+  if (verbose)
+    console.log("✓ Build complete");
+}
+
+export { exec, execAsync, spawnDevServer, startDevServers, getProcessOnPort, isPortInUse, killProcessOnPort, killProcessOnPortAndWait, killProcessesOnAppPorts, stopProcess, stopAllProcesses, isProcessAlive, buildApps };