buncargo 1.0.29 → 3.2.0

package/dist/index-vg55rq0y.js

@@ -0,0 +1,250 @@
+import {
+  resolveExposeTargets,
+  startPublicTunnels,
+  stopPublicTunnels
+} from "./index-yz4jfz7z.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 };

package/dist/index-vhs88xhe.js

@@ -1,120 +1,124 @@
-import {
-  isProcessAlive
-} from "./index-cty0bcry.js";
-
 // core/watchdog.ts
 import { spawn } from "node:child_process";
 import { existsSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
+import { isProcessAlive } from "./index-cty0bcry.js";
+
 function getHeartbeatFile(projectName) {
-  return `/tmp/${projectName}-heartbeat`;
+	return `/tmp/${projectName}-heartbeat`;
 }
 function getWatchdogPidFile(projectName) {
-  return `/tmp/${projectName}-watchdog.pid`;
+	return `/tmp/${projectName}-watchdog.pid`;
 }
 var heartbeatInterval = null;
 function startHeartbeat(projectName, intervalMs = 30000) {
-  const heartbeatFile = getHeartbeatFile(projectName);
-  writeFileSync(heartbeatFile, Date.now().toString());
-  heartbeatInterval = setInterval(() => {
-    writeFileSync(heartbeatFile, Date.now().toString());
-  }, intervalMs);
+	const heartbeatFile = getHeartbeatFile(projectName);
+	writeFileSync(heartbeatFile, Date.now().toString());
+	heartbeatInterval = setInterval(() => {
+		writeFileSync(heartbeatFile, Date.now().toString());
+	}, intervalMs);
 }
 function stopHeartbeat() {
-  if (heartbeatInterval) {
-    clearInterval(heartbeatInterval);
-    heartbeatInterval = null;
-  }
+	if (heartbeatInterval) {
+		clearInterval(heartbeatInterval);
+		heartbeatInterval = null;
+	}
 }
 function readHeartbeat(projectName) {
-  const heartbeatFile = getHeartbeatFile(projectName);
-  try {
-    if (!existsSync(heartbeatFile))
-      return null;
-    const content = readFileSync(heartbeatFile, "utf-8");
-    const timestamp = parseInt(content, 10);
-    return Number.isNaN(timestamp) ? null : timestamp;
-  } catch {
-    return null;
-  }
+	const heartbeatFile = getHeartbeatFile(projectName);
+	try {
+		if (!existsSync(heartbeatFile)) return null;
+		const content = readFileSync(heartbeatFile, "utf-8");
+		const timestamp = parseInt(content, 10);
+		return Number.isNaN(timestamp) ? null : timestamp;
+	} catch {
+		return null;
+	}
 }
 function removeHeartbeatFile(projectName) {
-  const heartbeatFile = getHeartbeatFile(projectName);
-  try {
-    unlinkSync(heartbeatFile);
-  } catch {}
+	const heartbeatFile = getHeartbeatFile(projectName);
+	try {
+		unlinkSync(heartbeatFile);
+	} catch {}
 }
 function isWatchdogRunning(projectName) {
-  const pidFile = getWatchdogPidFile(projectName);
-  try {
-    if (!existsSync(pidFile))
-      return false;
-    const content = readFileSync(pidFile, "utf-8");
-    const pid = parseInt(content, 10);
-    if (Number.isNaN(pid))
-      return false;
-    return isProcessAlive(pid);
-  } catch {
-    return false;
-  }
+	const pidFile = getWatchdogPidFile(projectName);
+	try {
+		if (!existsSync(pidFile)) return false;
+		const content = readFileSync(pidFile, "utf-8");
+		const pid = parseInt(content, 10);
+		if (Number.isNaN(pid)) return false;
+		return isProcessAlive(pid);
+	} catch {
+		return false;
+	}
 }
 function getWatchdogPid(projectName) {
-  const pidFile = getWatchdogPidFile(projectName);
-  try {
-    if (!existsSync(pidFile))
-      return null;
-    const content = readFileSync(pidFile, "utf-8");
-    const pid = parseInt(content, 10);
-    if (Number.isNaN(pid))
-      return null;
-    if (!isProcessAlive(pid))
-      return null;
-    return pid;
-  } catch {
-    return null;
-  }
+	const pidFile = getWatchdogPidFile(projectName);
+	try {
+		if (!existsSync(pidFile)) return null;
+		const content = readFileSync(pidFile, "utf-8");
+		const pid = parseInt(content, 10);
+		if (Number.isNaN(pid)) return null;
+		if (!isProcessAlive(pid)) return null;
+		return pid;
+	} catch {
+		return null;
+	}
 }
 async function spawnWatchdog(projectName, root, options = {}) {
-  const { timeoutMinutes = 10, verbose = true, composeFile } = options;
-  const existingPid = getWatchdogPid(projectName);
-  if (existingPid) {
-    if (verbose)
-      console.log(`✓ Watchdog already running (PID: ${existingPid})`);
-    return;
-  }
-  const pidFile = getWatchdogPidFile(projectName);
-  try {
-    unlinkSync(pidFile);
-  } catch {}
-  const watchdogScript = new URL("./watchdog-runner.ts", import.meta.url).pathname;
-  const proc = spawn("bun", ["run", watchdogScript], {
-    cwd: root,
-    detached: true,
-    stdio: "ignore",
-    env: {
-      ...process.env,
-      WATCHDOG_PROJECT_NAME: projectName,
-      WATCHDOG_HEARTBEAT_FILE: getHeartbeatFile(projectName),
-      WATCHDOG_PID_FILE: pidFile,
-      WATCHDOG_TIMEOUT_MS: String(timeoutMinutes * 60 * 1000),
-      WATCHDOG_COMPOSE_ARG: composeFile ? `-f ${composeFile}` : ""
-    }
-  });
-  proc.unref();
-  if (verbose && proc.pid) {
-    console.log(`✓ Watchdog started (PID: ${proc.pid})`);
-  }
+	const { timeoutMinutes = 10, verbose = true, composeFile } = options;
+	const existingPid = getWatchdogPid(projectName);
+	if (existingPid) {
+		if (verbose)
+			console.log(`✓ Watchdog already running (PID: ${existingPid})`);
+		return;
+	}
+	const pidFile = getWatchdogPidFile(projectName);
+	try {
+		unlinkSync(pidFile);
+	} catch {}
+	const watchdogScript = new URL("./watchdog-runner.ts", import.meta.url)
+		.pathname;
+	const proc = spawn("bun", ["run", watchdogScript], {
+		cwd: root,
+		detached: true,
+		stdio: "ignore",
+		env: {
+			...process.env,
+			WATCHDOG_PROJECT_NAME: projectName,
+			WATCHDOG_HEARTBEAT_FILE: getHeartbeatFile(projectName),
+			WATCHDOG_PID_FILE: pidFile,
+			WATCHDOG_TIMEOUT_MS: String(timeoutMinutes * 60 * 1000),
+			WATCHDOG_COMPOSE_ARG: composeFile ? `-f ${composeFile}` : "",
+		},
+	});
+	proc.unref();
+	if (verbose && proc.pid) {
+		console.log(`✓ Watchdog started (PID: ${proc.pid})`);
+	}
 }
 function stopWatchdog(projectName) {
-  const pid = getWatchdogPid(projectName);
-  if (pid) {
-    try {
-      process.kill(pid, "SIGTERM");
-    } catch {}
-  }
-  const pidFile = getWatchdogPidFile(projectName);
-  try {
-    unlinkSync(pidFile);
-  } catch {}
+	const pid = getWatchdogPid(projectName);
+	if (pid) {
+		try {
+			process.kill(pid, "SIGTERM");
+		} catch {}
+	}
+	const pidFile = getWatchdogPidFile(projectName);
+	try {
+		unlinkSync(pidFile);
+	} catch {}
 }
 
-export { getHeartbeatFile, getWatchdogPidFile, startHeartbeat, stopHeartbeat, readHeartbeat, removeHeartbeatFile, isWatchdogRunning, getWatchdogPid, spawnWatchdog, stopWatchdog };
+export {
+	getHeartbeatFile,
+	getWatchdogPidFile,
+	startHeartbeat,
+	stopHeartbeat,
+	readHeartbeat,
+	removeHeartbeatFile,
+	isWatchdogRunning,
+	getWatchdogPid,
+	spawnWatchdog,
+	stopWatchdog,
+};