buncargo 1.0.29 → 3.0.0

package/dist/index-c0dr6mcv.js

@@ -0,0 +1,123 @@
+import {
+  calculatePortOffset,
+  computePorts,
+  computeUrls
+} from "./index-fb29934k.js";
+
+// src/core/network.ts
+import { networkInterfaces } from "node:os";
+function getLocalIp() {
+  const interfaces = networkInterfaces();
+  for (const name of Object.keys(interfaces)) {
+    const nets = interfaces[name];
+    if (!nets)
+      continue;
+    for (const net of nets) {
+      if (net.family === "IPv4" && !net.internal) {
+        return net.address;
+      }
+    }
+  }
+  return "127.0.0.1";
+}
+async function waitForServer(url, options = {}) {
+  const { timeout = 30000, interval = 2000, verbose = false } = options;
+  const start = Date.now();
+  let attempts = 0;
+  while (Date.now() - start < timeout) {
+    attempts++;
+    const controller = new AbortController;
+    const timeoutId = setTimeout(() => controller.abort(), 5000);
+    try {
+      const response = await fetch(url, {
+        signal: controller.signal
+      });
+      clearTimeout(timeoutId);
+      if (response.ok || response.status === 404) {
+        if (verbose) {
+          console.log(`   ✓ ${url} ready after ${attempts} attempts`);
+        }
+        return;
+      }
+    } catch {
+      clearTimeout(timeoutId);
+      if (verbose && attempts % 5 === 0) {
+        console.log(`   ⏳ Waiting for ${url}... (${Math.round((Date.now() - start) / 1000)}s)`);
+      }
+    }
+    await sleep(interval);
+  }
+  throw new Error(`Server at ${url} did not respond within ${timeout}ms after ${attempts} attempts`);
+}
+async function waitForDevServers(apps, ports, options = {}) {
+  const { timeout = 60000, verbose = true } = options;
+  if (verbose)
+    console.log("⏳ Waiting for servers to be ready...");
+  const promises = [];
+  for (const [name, config] of Object.entries(apps)) {
+    const port = ports[name];
+    const healthPath = config.healthEndpoint ?? "/";
+    const url = `http://localhost:${port}${healthPath}`;
+    const appTimeout = config.healthTimeout ?? timeout;
+    promises.push(waitForServer(url, { timeout: appTimeout, verbose }));
+  }
+  await Promise.all(promises);
+  if (verbose)
+    console.log("✓ All servers ready");
+}
+async function isPortAvailable(port) {
+  const controller = new AbortController;
+  const timeoutId = setTimeout(() => controller.abort(), 500);
+  try {
+    const _response = await fetch(`http://localhost:${port}/`, {
+      signal: controller.signal
+    });
+    clearTimeout(timeoutId);
+    return false;
+  } catch (error) {
+    clearTimeout(timeoutId);
+    if (error instanceof Error) {
+      if (error.message.includes("ECONNREFUSED") || error.message.includes("fetch failed")) {
+        return true;
+      }
+    }
+    return true;
+  }
+}
+
+// src/core/utils.ts
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+function isCI() {
+  return process.env.CI === "true" || process.env.CI === "1" || process.env.GITHUB_ACTIONS === "true" || process.env.GITLAB_CI === "true" || process.env.CIRCLECI === "true" || process.env.JENKINS_URL !== undefined;
+}
+function logFrontendPort(port) {
+  console.log(`using_frontend_port:${port}`);
+}
+function getEnvVar(config, name, options = {}) {
+  const { log = true } = options;
+  const offset = calculatePortOffset();
+  const localIp = getLocalIp();
+  const ports = computePorts(config.services, config.apps, offset);
+  const urls = computeUrls(config.services, config.apps, ports, localIp);
+  const envVars = config.envVars?.(ports, urls, {
+    projectName: config.projectPrefix,
+    localIp,
+    portOffset: offset,
+    publicUrls: {}
+  });
+  const value = envVars?.[name];
+  if (log && name === "VITE_PORT" && typeof value === "number") {
+    logFrontendPort(value);
+  }
+  return value;
+}
+function logApiUrl(url) {
+  console.log(`using_api_url:${url}`);
+}
+function logExpoApiUrl(url) {
+  console.log(`using_expo_api_url:${url}`);
+}
+
+export { sleep, isCI, logFrontendPort, getEnvVar, logApiUrl, logExpoApiUrl, getLocalIp, waitForServer, waitForDevServers, isPortAvailable };

package/dist/index-cty0bcry.js

@@ -1,248 +1,265 @@
 // core/process.ts
-import {
-  execSync,
-  spawn
-} from "node:child_process";
+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}
+	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;
-  }
+		}
+		return result;
+	}
 }
 async function execAsync(cmd, root, envVars, options = {}) {
-  return new Promise((resolve2) => {
-    const result = exec(cmd, root, envVars, {
-      ...options,
-      throwOnError: false
-    });
-    resolve2(result);
-  });
+	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;
+	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;
+	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(`
+	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;
-  }
+			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;
+	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;
-  }
+	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;
+	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;
 }
 function stopProcess(pid) {
-  try {
-    process.kill(pid, "SIGTERM");
-  } catch {}
+	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);
-    }
-  }
+	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;
-  }
+	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");
+	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, stopProcess, stopAllProcesses, isProcessAlive, buildApps };
+export {
+	exec,
+	execAsync,
+	spawnDevServer,
+	startDevServers,
+	getProcessOnPort,
+	isPortInUse,
+	killProcessOnPort,
+	killProcessOnPortAndWait,
+	stopProcess,
+	stopAllProcesses,
+	isProcessAlive,
+	buildApps,
+};