buncargo 1.0.29 → 3.0.0

package/dist/index-mm412dkp.js

@@ -0,0 +1,274 @@
+// src/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 };