buncargo 1.0.26 → 3.0.0

package/dist/index-hkxtfqtc.js

@@ -0,0 +1,333 @@
+import {
+  logPublicUrls
+} from "./index-bnk6nr0g.js";
+import {
+  spawnWatchdog,
+  startHeartbeat,
+  stopHeartbeat
+} from "./index-mam0bcyz.js";
+import {
+  killProcessesOnAppPorts
+} from "./index-mm412dkp.js";
+
+// src/core/tunnel.ts
+import { startTunnel } from "untun";
+function parseExposeNames(exposeValue) {
+  if (exposeValue === undefined)
+    return null;
+  const names = exposeValue.split(",").map((name) => name.trim()).filter(Boolean);
+  return new Set(names);
+}
+function asPublicUrl(tunnel) {
+  return tunnel.url ?? tunnel.publicUrl ?? tunnel.tunnelUrl ?? null;
+}
+function toCloseFn(tunnel) {
+  const close = tunnel.close ?? tunnel.stop ?? tunnel.destroy;
+  if (!close)
+    return async () => {};
+  return async () => {
+    await close();
+  };
+}
+function resolveExposeTargets(env, exposeValue) {
+  const requestedNames = parseExposeNames(exposeValue);
+  const knownTargets = new Map;
+  const enabledTargets = new Map;
+  for (const [name, config] of Object.entries(env.services)) {
+    const port = env.ports[name];
+    if (port === undefined)
+      continue;
+    const target = { kind: "service", name, port };
+    knownTargets.set(name, target);
+    if (config.expose === true) {
+      enabledTargets.set(name, target);
+    }
+  }
+  for (const [name, config] of Object.entries(env.apps)) {
+    const port = env.ports[name];
+    if (port === undefined)
+      continue;
+    const target = { kind: "app", name, port };
+    knownTargets.set(name, target);
+    if (config.expose === true) {
+      enabledTargets.set(name, target);
+    }
+  }
+  if (requestedNames === null) {
+    return {
+      targets: Array.from(enabledTargets.values()),
+      unknownNames: [],
+      notEnabledNames: []
+    };
+  }
+  const unknownNames = [];
+  const notEnabledNames = [];
+  const targets = [];
+  for (const name of requestedNames) {
+    if (!knownTargets.has(name)) {
+      unknownNames.push(name);
+      continue;
+    }
+    const enabledTarget = enabledTargets.get(name);
+    if (!enabledTarget) {
+      notEnabledNames.push(name);
+      continue;
+    }
+    targets.push(enabledTarget);
+  }
+  return { targets, unknownNames, notEnabledNames };
+}
+async function startPublicTunnels(targets, options = {}) {
+  const start = options.start ?? ((input) => startTunnel(input));
+  const tunnels = [];
+  try {
+    for (const target of targets) {
+      const localUrl = `http://localhost:${target.port}`;
+      const tunnel = await start({
+        url: localUrl
+      });
+      const publicUrl = asPublicUrl(tunnel);
+      if (!publicUrl) {
+        throw new Error(`Tunnel for "${target.name}" did not provide a public URL`);
+      }
+      tunnels.push({
+        kind: target.kind,
+        name: target.name,
+        localUrl,
+        publicUrl,
+        close: toCloseFn(tunnel)
+      });
+    }
+    return tunnels;
+  } catch (error) {
+    await stopPublicTunnels(tunnels);
+    throw error;
+  }
+}
+async function stopPublicTunnels(tunnels) {
+  await Promise.allSettled(tunnels.map((tunnel) => tunnel.close()));
+}
+
+// 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
+  } = options;
+  const exposeRequested = hasFlag(args, "--expose");
+  const exposeValue = getFlagValue(args, "--expose");
+  let tunnels = [];
+  async function cleanupTunnels() {
+    if (tunnels.length === 0)
+      return;
+    await 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 });
+  if (exposeRequested) {
+    const { targets, unknownNames, notEnabledNames } = 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 startPublicTunnels(targets);
+    logPublicUrls(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.includes(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 { resolveExposeTargets, startPublicTunnels, stopPublicTunnels, runCli, hasFlag, getFlagValue };

package/dist/index-kf3dhser.js

@@ -1,160 +1,163 @@
+// cli.ts
+import { spawn } from "node:child_process";
 import {
-  spawnWatchdog,
-  startHeartbeat,
-  stopHeartbeat
-} from "./index-vhs88xhe.js";
-import {
-  getProcessOnPort,
-  killProcessOnPortAndWait
+	getProcessOnPort,
+	killProcessOnPortAndWait,
 } from "./index-cty0bcry.js";
+import {
+	spawnWatchdog,
+	startHeartbeat,
+	stopHeartbeat,
+} from "./index-vhs88xhe.js";
 
-// cli.ts
-import { spawn } from "node:child_process";
 async function runCli(env, options = {}) {
-  const {
-    args = process.argv.slice(2),
-    watchdog = true,
-    watchdogTimeout = 10,
-    devServersCommand
-  } = options;
-  env.logInfo();
-  if (args.includes("--down")) {
-    await env.stop();
-    process.exit(0);
-  }
-  if (args.includes("--reset")) {
-    await env.stop({ removeVolumes: true });
-    process.exit(0);
-  }
-  const running = await env.isRunning();
-  if (running) {
-    console.log("✓ Containers already running");
-  } else {
-    await env.start({ startServers: false, wait: true });
-  }
-  if (args.includes("--migrate")) {
-    console.log("");
-    console.log("✅ Migrations applied successfully");
-    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");
-      process.exit(1);
-    }
-    console.log("");
-    console.log("✅ Seeding complete");
-    process.exit(0);
-  }
-  if (args.includes("--up-only")) {
-    console.log("");
-    console.log("✅ Containers started. Environment ready.");
-    console.log("");
-    process.exit(0);
-  }
-  if (watchdog) {
-    await spawnWatchdog(env.projectName, env.root, {
-      timeoutMinutes: watchdogTimeout,
-      verbose: true
-    });
-    startHeartbeat(env.projectName);
-  }
-  const command = devServersCommand ?? buildDevServersCommand(env.apps);
-  if (!command) {
-    console.log("✅ Containers ready. No apps configured.");
-    await new Promise(() => {});
-    return;
-  }
-  await killExistingProcessesOnPorts(env.apps, env.ports);
-  console.log("");
-  console.log("\uD83D\uDD27 Starting dev servers...");
-  console.log("");
-  await runCommand(command, env.root, env.buildEnvVars());
-  stopHeartbeat();
+	const {
+		args = process.argv.slice(2),
+		watchdog = true,
+		watchdogTimeout = 10,
+		devServersCommand,
+	} = options;
+	env.logInfo();
+	if (args.includes("--down")) {
+		await env.stop();
+		process.exit(0);
+	}
+	if (args.includes("--reset")) {
+		await env.stop({ removeVolumes: true });
+		process.exit(0);
+	}
+	const running = await env.isRunning();
+	if (running) {
+		console.log("✓ Containers already running");
+	} else {
+		await env.start({ startServers: false, wait: true });
+	}
+	if (args.includes("--migrate")) {
+		console.log("");
+		console.log("✅ Migrations applied successfully");
+		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");
+			process.exit(1);
+		}
+		console.log("");
+		console.log("✅ Seeding complete");
+		process.exit(0);
+	}
+	if (args.includes("--up-only")) {
+		console.log("");
+		console.log("✅ Containers started. Environment ready.");
+		console.log("");
+		process.exit(0);
+	}
+	if (watchdog) {
+		await spawnWatchdog(env.projectName, env.root, {
+			timeoutMinutes: watchdogTimeout,
+			verbose: true,
+		});
+		startHeartbeat(env.projectName);
+	}
+	const command = devServersCommand ?? buildDevServersCommand(env.apps);
+	if (!command) {
+		console.log("✅ Containers ready. No apps configured.");
+		await new Promise(() => {});
+		return;
+	}
+	await killExistingProcessesOnPorts(env.apps, env.ports);
+	console.log("");
+	console.log("\uD83D\uDD27 Starting dev servers...");
+	console.log("");
+	await runCommand(command, env.root, env.buildEnvVars());
+	stopHeartbeat();
 }
 async function killExistingProcessesOnPorts(apps, ports) {
-  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) {
-        console.log("");
-        killedAny = true;
-      }
-      console.log(`⚠️  Port ${port} (${name}) is in use by process ${existingPid}`);
-      const killed = await killProcessOnPortAndWait(port, { verbose: true });
-      if (!killed) {
-        console.log(`   ⚠️  Could not kill process on port ${port}, server may fail to start`);
-      }
-    }
-  }
+	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) {
+				console.log("");
+				killedAny = true;
+			}
+			console.log(
+				`⚠️  Port ${port} (${name}) is in use by process ${existingPid}`,
+			);
+			const killed = await killProcessOnPortAndWait(port, { verbose: true });
+			if (!killed) {
+				console.log(
+					`   ⚠️  Could not kill process on port ${port}, server may fail to start`,
+				);
+			}
+		}
+	}
 }
 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}`;
+	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) {
-  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 = () => {
-      proc.kill("SIGTERM");
-    };
-    process.on("SIGINT", cleanup);
-    process.on("SIGTERM", cleanup);
-  });
+	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 = () => {
+			proc.kill("SIGTERM");
+		};
+		process.on("SIGINT", cleanup);
+		process.on("SIGTERM", cleanup);
+	});
 }
 function hasFlag(args, flag) {
-  return args.includes(flag);
+	return args.includes(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;
+	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 };