buncargo 1.0.29 → 3.0.0

package/dist/index-08wa79cs.js

@@ -1,141 +1,149 @@
 // core/ports.ts
 import { existsSync, readFileSync, statSync } from "node:fs";
 import { basename, dirname, resolve } from "node:path";
+
 function findMonorepoRoot(startDir) {
-  let dir = startDir ?? process.cwd();
-  while (dir !== "/") {
-    try {
-      const pkgPath = resolve(dir, "package.json");
-      if (existsSync(pkgPath)) {
-        const content = readFileSync(pkgPath, "utf-8");
-        const pkg = JSON.parse(content);
-        if (pkg.workspaces) {
-          return dir;
-        }
-      }
-    } catch {}
-    dir = dirname(dir);
-  }
-  return process.cwd();
+	let dir = startDir ?? process.cwd();
+	while (dir !== "/") {
+		try {
+			const pkgPath = resolve(dir, "package.json");
+			if (existsSync(pkgPath)) {
+				const content = readFileSync(pkgPath, "utf-8");
+				const pkg = JSON.parse(content);
+				if (pkg.workspaces) {
+					return dir;
+				}
+			}
+		} catch {}
+		dir = dirname(dir);
+	}
+	return process.cwd();
 }
 function getWorktreeName(root) {
-  const monorepoRoot = root ?? findMonorepoRoot();
-  const gitPath = resolve(monorepoRoot, ".git");
-  try {
-    if (!existsSync(gitPath) || !statSync(gitPath).isFile())
-      return null;
-    const content = readFileSync(gitPath, "utf-8").trim();
-    const match = content.match(/^gitdir:\s*(.+)$/);
-    if (!match?.[1])
-      return null;
-    return basename(match[1]);
-  } catch {
-    return null;
-  }
+	const monorepoRoot = root ?? findMonorepoRoot();
+	const gitPath = resolve(monorepoRoot, ".git");
+	try {
+		if (!existsSync(gitPath) || !statSync(gitPath).isFile()) return null;
+		const content = readFileSync(gitPath, "utf-8").trim();
+		const match = content.match(/^gitdir:\s*(.+)$/);
+		if (!match?.[1]) return null;
+		return basename(match[1]);
+	} catch {
+		return null;
+	}
 }
 function isWorktree(root) {
-  return getWorktreeName(root) !== null;
+	return getWorktreeName(root) !== null;
 }
 function simpleHash(str) {
-  let hash = 0;
-  for (let i = 0;i < str.length; i++) {
-    const char = str.charCodeAt(i);
-    hash = (hash << 5) - hash + char;
-    hash = hash & hash;
-  }
-  return Math.abs(hash);
+	let hash = 0;
+	for (let i = 0; i < str.length; i++) {
+		const char = str.charCodeAt(i);
+		hash = (hash << 5) - hash + char;
+		hash = hash & hash;
+	}
+	return Math.abs(hash);
 }
 function calculatePortOffset(suffix, root) {
-  const worktreeName = getWorktreeName(root);
-  if (!worktreeName)
-    return 0;
-  const hashInput = suffix ? `${worktreeName}-${suffix}` : worktreeName;
-  return 10 + simpleHash(hashInput) % 90;
+	const worktreeName = getWorktreeName(root);
+	if (!worktreeName) return 0;
+	const hashInput = suffix ? `${worktreeName}-${suffix}` : worktreeName;
+	return 10 + (simpleHash(hashInput) % 90);
 }
 function getProjectName(prefix, suffix, root) {
-  const monorepoRoot = root ?? findMonorepoRoot();
-  const dirName = basename(monorepoRoot);
-  const baseName = `${prefix}-${dirName.toLowerCase().replace(/[^a-z0-9-]/g, "-")}`;
-  return suffix ? `${baseName}-${suffix}` : baseName;
+	const monorepoRoot = root ?? findMonorepoRoot();
+	const dirName = basename(monorepoRoot);
+	const baseName = `${prefix}-${dirName.toLowerCase().replace(/[^a-z0-9-]/g, "-")}`;
+	return suffix ? `${baseName}-${suffix}` : baseName;
 }
 function computePorts(services, apps, offset) {
-  const ports = {};
-  for (const [name, config] of Object.entries(services)) {
-    ports[name] = config.port + offset;
-    if (config.secondaryPort) {
-      ports[`${name}Secondary`] = config.secondaryPort + offset;
-    }
-  }
-  if (apps) {
-    for (const [name, config] of Object.entries(apps)) {
-      ports[name] = config.port + offset;
-    }
-  }
-  return ports;
+	const ports = {};
+	for (const [name, config] of Object.entries(services)) {
+		ports[name] = config.port + offset;
+		if (config.secondaryPort) {
+			ports[`${name}Secondary`] = config.secondaryPort + offset;
+		}
+	}
+	if (apps) {
+		for (const [name, config] of Object.entries(apps)) {
+			ports[name] = config.port + offset;
+		}
+	}
+	return ports;
 }
 var SERVICE_DEFAULTS = {
-  postgres: { user: "postgres", password: "postgres", database: "postgres" },
-  postgresql: { user: "postgres", password: "postgres", database: "postgres" },
-  redis: { user: "", password: "", database: "" },
-  clickhouse: { user: "default", password: "clickhouse", database: "default" },
-  mysql: { user: "root", password: "root", database: "mysql" },
-  mongodb: { user: "", password: "", database: "" }
+	postgres: { user: "postgres", password: "postgres", database: "postgres" },
+	postgresql: { user: "postgres", password: "postgres", database: "postgres" },
+	redis: { user: "", password: "", database: "" },
+	clickhouse: { user: "default", password: "clickhouse", database: "default" },
+	mysql: { user: "root", password: "root", database: "mysql" },
+	mongodb: { user: "", password: "", database: "" },
 };
 function buildServiceUrl(serviceName, ctx, config) {
-  const defaults = SERVICE_DEFAULTS[serviceName];
-  if (!defaults && !config.database)
-    return null;
-  const user = config.user ?? defaults?.user ?? "";
-  const password = config.password ?? defaults?.password ?? "";
-  const database = config.database ?? defaults?.database ?? "";
-  switch (serviceName) {
-    case "postgres":
-    case "postgresql":
-      return `postgresql://${user}:${password}@${ctx.host}:${ctx.port}/${database}`;
-    case "redis":
-      return `redis://${ctx.host}:${ctx.port}`;
-    case "clickhouse":
-      return `http://${user}:${password}@${ctx.host}:${ctx.port}/${database}`;
-    case "mysql":
-      return `mysql://${user}:${password}@${ctx.host}:${ctx.port}/${database}`;
-    case "mongodb":
-      return `mongodb://${ctx.host}:${ctx.port}/${database}`;
-    default:
-      return null;
-  }
+	const defaults = SERVICE_DEFAULTS[serviceName];
+	if (!defaults && !config.database) return null;
+	const user = config.user ?? defaults?.user ?? "";
+	const password = config.password ?? defaults?.password ?? "";
+	const database = config.database ?? defaults?.database ?? "";
+	switch (serviceName) {
+		case "postgres":
+		case "postgresql":
+			return `postgresql://${user}:${password}@${ctx.host}:${ctx.port}/${database}`;
+		case "redis":
+			return `redis://${ctx.host}:${ctx.port}`;
+		case "clickhouse":
+			return `http://${user}:${password}@${ctx.host}:${ctx.port}/${database}`;
+		case "mysql":
+			return `mysql://${user}:${password}@${ctx.host}:${ctx.port}/${database}`;
+		case "mongodb":
+			return `mongodb://${ctx.host}:${ctx.port}/${database}`;
+		default:
+			return null;
+	}
 }
 function computeUrls(services, apps, ports, localIp) {
-  const urls = {};
-  const host = "localhost";
-  for (const [name, config] of Object.entries(services)) {
-    const port = ports[name];
-    const secondaryPort = ports[`${name}Secondary`];
-    if (port === undefined)
-      continue;
-    const ctx = { port, secondaryPort, host, localIp };
-    if (config.urlTemplate) {
-      urls[name] = config.urlTemplate(ctx);
-    } else {
-      const builtUrl = buildServiceUrl(name, { port, host }, {
-        database: config.database,
-        user: config.user,
-        password: config.password
-      });
-      if (builtUrl) {
-        urls[name] = builtUrl;
-      } else {
-        urls[name] = `http://${host}:${port}`;
-      }
-    }
-  }
-  if (apps) {
-    for (const [name, _config] of Object.entries(apps)) {
-      const port = ports[name];
-      urls[name] = `http://${host}:${port}`;
-      urls[`${name}Local`] = `http://${localIp}:${port}`;
-    }
-  }
-  return urls;
+	const urls = {};
+	const host = "localhost";
+	for (const [name, config] of Object.entries(services)) {
+		const port = ports[name];
+		const secondaryPort = ports[`${name}Secondary`];
+		if (port === undefined) continue;
+		const ctx = { port, secondaryPort, host, localIp };
+		if (config.urlTemplate) {
+			urls[name] = config.urlTemplate(ctx);
+		} else {
+			const builtUrl = buildServiceUrl(
+				name,
+				{ port, host },
+				{
+					database: config.database,
+					user: config.user,
+					password: config.password,
+				},
+			);
+			if (builtUrl) {
+				urls[name] = builtUrl;
+			} else {
+				urls[name] = `http://${host}:${port}`;
+			}
+		}
+	}
+	if (apps) {
+		for (const [name, _config] of Object.entries(apps)) {
+			const port = ports[name];
+			urls[name] = `http://${host}:${port}`;
+			urls[`${name}Local`] = `http://${localIp}:${port}`;
+		}
+	}
+	return urls;
 }
 
-export { findMonorepoRoot, getWorktreeName, isWorktree, calculatePortOffset, getProjectName, computePorts, computeUrls };
+export {
+	findMonorepoRoot,
+	getWorktreeName,
+	isWorktree,
+	calculatePortOffset,
+	getProjectName,
+	computePorts,
+	computeUrls,
+};

package/dist/index-0kxnae3z.js

@@ -0,0 +1,335 @@
+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() {
+    env.clearPublicUrls();
+    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);
+    env.setPublicUrls(Object.fromEntries(tunnels.map((tunnel) => [tunnel.name, tunnel.publicUrl])));
+    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 };