buncargo 1.0.29 → 3.2.0

package/dist/index-42x95209.js

@@ -1,58 +1,66 @@
-import {
-  createDevEnvironment
-} from "./index-p8wty0e2.js";
-
 // loader.ts
 import { existsSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { createDevEnvironment } from "./index-p8wty0e2.js";
+
 var CONFIG_FILES = [
-  "dev.config.ts",
-  "dev.config.js",
-  "dev-tools.config.ts",
-  "dev-tools.config.js"
+	"dev.config.ts",
+	"dev.config.js",
+	"dev-tools.config.ts",
+	"dev-tools.config.js",
 ];
 function findConfigFile(startDir) {
-  let currentDir = startDir;
-  while (true) {
-    for (const file of CONFIG_FILES) {
-      const configPath = join(currentDir, file);
-      if (existsSync(configPath)) {
-        return configPath;
-      }
-    }
-    const parentDir = dirname(currentDir);
-    if (parentDir === currentDir) {
-      return null;
-    }
-    currentDir = parentDir;
-  }
+	let currentDir = startDir;
+	while (true) {
+		for (const file of CONFIG_FILES) {
+			const configPath = join(currentDir, file);
+			if (existsSync(configPath)) {
+				return configPath;
+			}
+		}
+		const parentDir = dirname(currentDir);
+		if (parentDir === currentDir) {
+			return null;
+		}
+		currentDir = parentDir;
+	}
 }
 var cachedEnv = null;
 async function loadDevEnv(options) {
-  if (cachedEnv && !options?.reload) {
-    return cachedEnv;
-  }
-  const cwd = options?.cwd ?? process.cwd();
-  const configPath = findConfigFile(cwd);
-  if (configPath) {
-    const mod = await import(configPath);
-    const config = mod.default;
-    if (!config?.projectPrefix || !config?.services) {
-      throw new Error(`Invalid config in "${configPath}". Use defineDevConfig() and export as default.`);
-    }
-    cachedEnv = createDevEnvironment(config);
-    return cachedEnv;
-  }
-  throw new Error(`No config file found. Create dev.config.ts with: export default defineDevConfig({ ... })`);
+	if (cachedEnv && !options?.reload) {
+		return cachedEnv;
+	}
+	const cwd = options?.cwd ?? process.cwd();
+	const configPath = findConfigFile(cwd);
+	if (configPath) {
+		const mod = await import(configPath);
+		const config = mod.default;
+		if (!config?.projectPrefix || !config?.services) {
+			throw new Error(
+				`Invalid config in "${configPath}". Use defineDevConfig() and export as default.`,
+			);
+		}
+		cachedEnv = createDevEnvironment(config);
+		return cachedEnv;
+	}
+	throw new Error(
+		`No config file found. Create dev.config.ts with: export default defineDevConfig({ ... })`,
+	);
 }
 function getDevEnv() {
-  if (!cachedEnv) {
-    throw new Error("Dev environment not loaded. Call loadDevEnv() first.");
-  }
-  return cachedEnv;
+	if (!cachedEnv) {
+		throw new Error("Dev environment not loaded. Call loadDevEnv() first.");
+	}
+	return cachedEnv;
 }
 function clearDevEnvCache() {
-  cachedEnv = null;
+	cachedEnv = null;
 }
 
-export { CONFIG_FILES, findConfigFile, loadDevEnv, getDevEnv, clearDevEnvCache };
+export {
+	CONFIG_FILES,
+	findConfigFile,
+	loadDevEnv,
+	getDevEnv,
+	clearDevEnvCache,
+};

package/dist/index-4gp0az1g.js

@@ -0,0 +1,145 @@
+// src/core/network.ts
+import { networkInterfaces } from "node:os";
+import {
+	calculatePortOffset,
+	computePorts,
+	computeUrls,
+} from "./index-xkvd0nsd.js";
+
+// 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,
+	});
+	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}`);
+}
+
+// src/core/network.ts
+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;
+	}
+}
+
+export {
+	getLocalIp,
+	waitForServer,
+	waitForDevServers,
+	isPortAvailable,
+	sleep,
+	isCI,
+	logFrontendPort,
+	getEnvVar,
+	logApiUrl,
+	logExpoApiUrl,
+};

package/dist/index-4xrxh8yv.js

@@ -0,0 +1,72 @@
+import {
+  createDevEnvironment
+} from "./index-ma6tgdb2.js";
+
+// src/loader/cache.ts
+var cachedEnv = null;
+function setCachedDevEnv(env) {
+  cachedEnv = env;
+}
+function getCachedDevEnv() {
+  return cachedEnv;
+}
+function clearDevEnvCache() {
+  cachedEnv = null;
+}
+// src/loader/find-config-file.ts
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+var CONFIG_FILES = [
+  "dev.config.ts",
+  "dev.config.js",
+  "dev-tools.config.ts",
+  "dev-tools.config.js"
+];
+function findConfigFile(startDir) {
+  let currentDir = startDir;
+  while (true) {
+    for (const file of CONFIG_FILES) {
+      const configPath = join(currentDir, file);
+      if (existsSync(configPath)) {
+        return configPath;
+      }
+    }
+    const parentDir = dirname(currentDir);
+    if (parentDir === currentDir) {
+      return null;
+    }
+    currentDir = parentDir;
+  }
+}
+// src/loader/load-dev-env.ts
+async function loadDevEnv(options) {
+  if (!options?.reload) {
+    const cached = getCachedDevEnv();
+    if (cached)
+      return cached;
+  }
+  const cwd = options?.cwd ?? process.cwd();
+  const configPath = findConfigFile(cwd);
+  if (configPath) {
+    const mod = await import(configPath);
+    const config = mod.default;
+    if (!config?.projectPrefix || !config?.services) {
+      throw new Error(`Invalid config in "${configPath}". Use defineDevConfig() and export as default.`);
+    }
+    const env = createDevEnvironment(config);
+    setCachedDevEnv(env);
+    return env;
+  }
+  throw new Error("No config file found. Create dev.config.ts with: export default defineDevConfig({ ... })");
+}
+
+// src/loader/index.ts
+function getDevEnv() {
+  const env = getCachedDevEnv();
+  if (!env) {
+    throw new Error("Dev environment not loaded. Call loadDevEnv() first.");
+  }
+  return env;
+}
+
+export { clearDevEnvCache, CONFIG_FILES, findConfigFile, loadDevEnv, getDevEnv };

package/dist/index-5aq985p4.js

@@ -0,0 +1,250 @@
+import {
+  resolveExposeTargets,
+  startPublicTunnels,
+  stopPublicTunnels
+} from "./index-x54nbgs7.js";
+import {
+  spawnWatchdog,
+  startHeartbeat,
+  stopHeartbeat
+} from "./index-mam0bcyz.js";
+import {
+  killProcessesOnAppPorts
+} from "./index-mm412dkp.js";
+
+// src/cli/run-cli.ts
+import { spawn } from "node:child_process";
+var ACCEPTED_FLAGS = [
+  "--help",
+  "--down",
+  "--reset",
+  "--migrate",
+  "--seed",
+  "--up-only",
+  "--expose"
+];
+function printHelp() {
+  console.log(`
+Usage: buncargo dev [options]
+
+Options:
+  --help      Show this help message
+  --down      Stop all containers
+  --reset     Stop containers and remove volumes (fresh start)
+  --migrate   Run migrations and exit
+  --seed      Run migrations and seeders, then exit
+  --up-only   Start containers and run migrations, then exit (no dev servers)
+  --expose    Expose configured targets via public quick tunnels
+
+Examples:
+  bun dev              Start dev environment with all services
+  bun dev --seed       Run migrations and seed the database
+  bun dev --down       Stop all containers
+  bun dev --reset      Stop containers and remove all data
+  bun dev --expose     Expose all targets with expose: true
+  bun dev --expose=api,web  Expose specific targets
+`);
+}
+function getUnknownFlags(args) {
+  return args.filter((arg) => arg.startsWith("--") && !ACCEPTED_FLAGS.includes(arg.includes("=") ? arg.split("=")[0] : arg));
+}
+async function runCli(env, options = {}) {
+  const {
+    args = process.argv.slice(2),
+    watchdog = true,
+    watchdogTimeout = 10,
+    devServersCommand,
+    cliTestTunnel
+  } = options;
+  const tunnelApi = cliTestTunnel ?? {
+    resolveExposeTargets,
+    startPublicTunnels,
+    stopPublicTunnels
+  };
+  const exposeRequested = hasFlag(args, "--expose");
+  const exposeValue = getFlagValue(args, "--expose");
+  let tunnels = [];
+  async function cleanupTunnels() {
+    env.clearPublicUrls();
+    if (tunnels.length === 0)
+      return;
+    await tunnelApi.stopPublicTunnels(tunnels);
+    tunnels = [];
+  }
+  if (args.includes("--help")) {
+    printHelp();
+    process.exit(0);
+  }
+  const unknownFlags = getUnknownFlags(args);
+  if (unknownFlags.length > 0) {
+    console.error(`❌ Unknown flag${unknownFlags.length > 1 ? "s" : ""}: ${unknownFlags.join(", ")}`);
+    console.error("");
+    printHelp();
+    process.exit(1);
+  }
+  if (args.includes("--down")) {
+    env.logInfo();
+    await cleanupTunnels();
+    await env.stop();
+    process.exit(0);
+  }
+  if (args.includes("--reset")) {
+    env.logInfo();
+    await cleanupTunnels();
+    await env.stop({ removeVolumes: true });
+    process.exit(0);
+  }
+  const skipSeed = args.includes("--seed");
+  await env.start({
+    startServers: false,
+    wait: true,
+    skipSeed,
+    skipEnvironmentLog: exposeRequested
+  });
+  if (exposeRequested) {
+    const { targets, unknownNames, notEnabledNames } = tunnelApi.resolveExposeTargets(env, exposeValue);
+    if (unknownNames.length > 0) {
+      console.error(`❌ Unknown expose target${unknownNames.length > 1 ? "s" : ""}: ${unknownNames.join(", ")}`);
+      await cleanupTunnels();
+      process.exit(1);
+    }
+    if (notEnabledNames.length > 0) {
+      console.error(`❌ Target${notEnabledNames.length > 1 ? "s" : ""} missing expose: true: ${notEnabledNames.join(", ")}`);
+      console.error("   Mark these in dev.config.ts with expose: true or remove them from --expose.");
+      await cleanupTunnels();
+      process.exit(1);
+    }
+    if (targets.length === 0) {
+      console.error("❌ No expose targets selected. Add expose: true to services/apps or pass names with --expose=<name>.");
+      await cleanupTunnels();
+      process.exit(1);
+    }
+    tunnels = await tunnelApi.startPublicTunnels(targets);
+    env.setPublicUrls(Object.fromEntries(tunnels.map((tunnel) => [tunnel.name, tunnel.publicUrl])));
+    env.logInfo("Dev Environment", tunnels);
+  }
+  if (args.includes("--migrate")) {
+    console.log("");
+    console.log("✅ Migrations applied successfully");
+    await cleanupTunnels();
+    process.exit(0);
+  }
+  if (args.includes("--seed")) {
+    console.log("\uD83C\uDF31 Running seeders...");
+    const result = await env.exec("bun run run:seeder", {
+      throwOnError: false
+    });
+    if (result.exitCode !== 0) {
+      console.error("❌ Seeding failed");
+      if (result.stderr) {
+        console.error(result.stderr);
+      }
+      if (result.stdout) {
+        console.error(result.stdout);
+      }
+      await cleanupTunnels();
+      process.exit(1);
+    }
+    console.log("");
+    console.log("✅ Seeding complete");
+    await cleanupTunnels();
+    process.exit(0);
+  }
+  if (args.includes("--up-only")) {
+    console.log("");
+    console.log("✅ Containers started. Environment ready.");
+    console.log("");
+    await cleanupTunnels();
+    process.exit(0);
+  }
+  if (watchdog) {
+    await spawnWatchdog(env.projectName, env.root, {
+      timeoutMinutes: watchdogTimeout,
+      verbose: true,
+      composeFile: env.composeFile
+    });
+    startHeartbeat(env.projectName);
+  }
+  const command = devServersCommand ?? buildDevServersCommand(env.apps);
+  if (!command) {
+    console.log("✅ Containers ready. No apps configured.");
+    await new Promise(() => {});
+    await cleanupTunnels();
+    return;
+  }
+  await killProcessesOnAppPorts(env.apps, env.ports);
+  console.log("");
+  console.log("\uD83D\uDD27 Starting dev servers...");
+  console.log("");
+  await runCommand(command, env.root, env.buildEnvVars(), {
+    onSignal: async () => {
+      await cleanupTunnels();
+      stopHeartbeat();
+    }
+  });
+  stopHeartbeat();
+  await cleanupTunnels();
+}
+function buildDevServersCommand(apps) {
+  const appEntries = Object.entries(apps);
+  if (appEntries.length === 0)
+    return null;
+  const commands = [];
+  const names = [];
+  const colors = ["blue", "green", "yellow", "magenta", "cyan", "red"];
+  for (const [name, config] of appEntries) {
+    names.push(name);
+    const cwdPart = config.cwd ? `--cwd ${config.cwd}` : "";
+    commands.push(`"bun run ${cwdPart} ${config.devCommand}"`.replace(/\s+/g, " ").trim());
+  }
+  const namesArg = `-n ${names.join(",")}`;
+  const colorsArg = `-c ${colors.slice(0, names.length).join(",")}`;
+  const commandsArg = commands.join(" ");
+  return `bun concurrently ${namesArg} ${colorsArg} ${commandsArg}`;
+}
+function runCommand(command, cwd, envVars, options = {}) {
+  const { onSignal } = options;
+  return new Promise((resolve, reject) => {
+    const proc = spawn(command, [], {
+      cwd,
+      env: { ...process.env, ...envVars },
+      stdio: "inherit",
+      shell: true
+    });
+    proc.on("close", (code) => {
+      if (code === 0 || code === null) {
+        resolve();
+      } else {
+        reject(new Error(`Command exited with code ${code}`));
+      }
+    });
+    proc.on("error", reject);
+    const cleanup = () => {
+      if (onSignal) {
+        onSignal();
+      }
+      proc.kill("SIGTERM");
+    };
+    process.on("SIGINT", cleanup);
+    process.on("SIGTERM", cleanup);
+  });
+}
+function hasFlag(args, flag) {
+  return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
+}
+function getFlagValue(args, flag) {
+  const prefixed = args.find((arg) => arg.startsWith(`${flag}=`));
+  if (prefixed) {
+    return prefixed.split("=")[1];
+  }
+  const index = args.indexOf(flag);
+  if (index !== -1 && index + 1 < args.length) {
+    const nextArg = args[index + 1];
+    if (nextArg !== undefined && !nextArg.startsWith("-")) {
+      return nextArg;
+    }
+  }
+  return;
+}
+
+export { runCli, hasFlag, getFlagValue };