buncargo 3.2.3 → 3.2.4

package/dist/index-qz66apm2.js

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

@@ -0,0 +1,228 @@
+import {
+  sleep
+} from "./index-fkgqg6w2.js";
+
+// src/docker/runtime.ts
+import { execSync } from "node:child_process";
+var POLL_INTERVAL = 250;
+var MAX_ATTEMPTS = 120;
+var DOCKER_NOT_RUNNING_MESSAGE = "Docker is not running. Please start Docker and try again.";
+async function isContainerRunning(project, service) {
+  try {
+    const result = execSync(`docker ps --filter "label=com.docker.compose.project=${project}" --filter "label=com.docker.compose.service=${service}" --format "{{.State}}"`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    return result.trim() === "running";
+  } catch {
+    return false;
+  }
+}
+function isDockerRunning() {
+  try {
+    execSync('docker info --format "{{.ServerVersion}}"', {
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return true;
+  } catch {
+    return false;
+  }
+}
+function assertDockerRunning() {
+  if (!isDockerRunning()) {
+    throw new Error(DOCKER_NOT_RUNNING_MESSAGE);
+  }
+}
+async function areContainersRunning(project, minCount = 1) {
+  try {
+    const result = execSync(`docker ps --filter "label=com.docker.compose.project=${project}" --format "{{.State}}"`, { encoding: "utf-8", stdio: ["pipe", "pipe", "pipe"] });
+    const states = result.trim().split(`
+`).filter(Boolean);
+    if (states.length < minCount)
+      return false;
+    return states.every((state) => state === "running");
+  } catch {
+    return false;
+  }
+}
+function getComposeArg(composeFile) {
+  return composeFile ? `-f "${composeFile}"` : "";
+}
+function startContainers(root, projectName, envVars, options = {}) {
+  const { verbose = true, wait = true, composeFile } = options;
+  assertDockerRunning();
+  if (verbose)
+    console.log("\uD83D\uDC33 Starting Docker containers...");
+  const composeArg = getComposeArg(composeFile);
+  const waitFlag = wait ? "--wait" : "";
+  const cmd = `docker compose ${composeArg} up -d ${waitFlag}`.trim();
+  execSync(cmd, {
+    cwd: root,
+    env: { ...process.env, ...envVars, COMPOSE_PROJECT_NAME: projectName },
+    stdio: verbose ? "inherit" : "ignore"
+  });
+  if (verbose)
+    console.log("✓ Containers started");
+}
+function stopContainers(root, projectName, options = {}) {
+  const { verbose = true, removeVolumes = false, composeFile } = options;
+  assertDockerRunning();
+  if (verbose) {
+    console.log(removeVolumes ? "\uD83D\uDDD1️  Stopping containers and removing volumes..." : "\uD83D\uDED1 Stopping containers...");
+  }
+  const composeArg = getComposeArg(composeFile);
+  const volumeFlag = removeVolumes ? "-v" : "";
+  const cmd = `docker compose ${composeArg} down ${volumeFlag}`.trim();
+  execSync(cmd, {
+    cwd: root,
+    env: { ...process.env, COMPOSE_PROJECT_NAME: projectName },
+    stdio: verbose ? "inherit" : "ignore"
+  });
+  if (verbose)
+    console.log("✓ Containers stopped");
+}
+function startService(root, projectName, serviceName, envVars, options = {}) {
+  const { verbose = true, composeFile } = options;
+  assertDockerRunning();
+  if (verbose)
+    console.log(`\uD83D\uDC33 Starting ${serviceName}...`);
+  const composeArg = getComposeArg(composeFile);
+  const cmd = `docker compose ${composeArg} up -d ${serviceName}`.trim();
+  execSync(cmd, {
+    cwd: root,
+    env: { ...process.env, ...envVars, COMPOSE_PROJECT_NAME: projectName },
+    stdio: verbose ? "inherit" : "ignore"
+  });
+}
+function createBuiltInHealthCheck(type, serviceName, context = {}) {
+  const { projectName, root } = context;
+  switch (type) {
+    case "pg_isready":
+      return async () => {
+        try {
+          const projectArg = projectName ? `-p ${projectName}` : "";
+          execSync(`docker compose ${projectArg} exec -T ${serviceName} pg_isready -U postgres`, {
+            cwd: root,
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      };
+    case "redis-cli":
+      return async () => {
+        try {
+          const projectArg = projectName ? `-p ${projectName}` : "";
+          execSync(`docker compose ${projectArg} exec -T ${serviceName} redis-cli ping`, {
+            cwd: root,
+            stdio: ["pipe", "pipe", "pipe"]
+          });
+          return true;
+        } catch {
+          return false;
+        }
+      };
+    case "http":
+      return async (port) => {
+        try {
+          const controller = new AbortController;
+          const timeoutId = setTimeout(() => controller.abort(), 2000);
+          try {
+            const response = await fetch(`http://localhost:${port}/`, {
+              signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            return response.ok || response.status === 404;
+          } catch {
+            clearTimeout(timeoutId);
+            return false;
+          }
+        } catch {
+          return false;
+        }
+      };
+    case "tcp":
+      return async (port) => {
+        try {
+          const controller = new AbortController;
+          const timeoutId = setTimeout(() => controller.abort(), 1000);
+          try {
+            await fetch(`http://localhost:${port}/`, {
+              signal: controller.signal
+            });
+            clearTimeout(timeoutId);
+            return true;
+          } catch (error) {
+            clearTimeout(timeoutId);
+            if (error instanceof Error && error.message.includes("ECONNREFUSED")) {
+              return false;
+            }
+            return true;
+          }
+        } catch {
+          return false;
+        }
+      };
+    default:
+      return async () => true;
+  }
+}
+async function waitForService(serviceName, config, port, options = {}) {
+  const {
+    maxAttempts = MAX_ATTEMPTS,
+    pollInterval = POLL_INTERVAL,
+    projectName,
+    root
+  } = options;
+  if (config.healthCheck === false || config.healthCheck === undefined) {
+    return;
+  }
+  const healthCheckFn = typeof config.healthCheck === "function" ? config.healthCheck : createBuiltInHealthCheck(config.healthCheck, config.serviceName ?? serviceName, { projectName, root });
+  for (let i = 0;i < maxAttempts; i++) {
+    const isHealthy = await healthCheckFn(port);
+    if (isHealthy)
+      return;
+    await sleep(pollInterval);
+  }
+  throw new Error(`Service ${serviceName} did not become ready in time`);
+}
+async function waitForAllServices(services, ports, options = {}) {
+  const { verbose = true, ...waitOptions } = options;
+  if (verbose)
+    console.log("⏳ Waiting for services to be healthy...");
+  const promises = Object.entries(services).map(([name, config]) => {
+    const port = ports[name];
+    if (port === undefined) {
+      console.warn(`⚠️  No port found for service ${name}, skipping health check`);
+      return Promise.resolve();
+    }
+    return waitForService(name, config, port, waitOptions);
+  });
+  await Promise.all(promises);
+  if (verbose)
+    console.log("✓ All services healthy");
+}
+async function waitForServiceByType(serviceName, healthCheckType, port, options = {}) {
+  const {
+    maxAttempts = MAX_ATTEMPTS,
+    pollInterval = POLL_INTERVAL,
+    verbose = false,
+    projectName,
+    root
+  } = options;
+  const healthCheckFn = createBuiltInHealthCheck(healthCheckType, serviceName, {
+    projectName,
+    root
+  });
+  for (let i = 0;i < maxAttempts; i++) {
+    const isHealthy = await healthCheckFn(port);
+    if (isHealthy) {
+      if (verbose)
+        console.log(`✓ ${serviceName} is ready`);
+      return;
+    }
+    await sleep(pollInterval);
+  }
+  throw new Error(`Service ${serviceName} did not become ready in time`);
+}
+
+export { POLL_INTERVAL, MAX_ATTEMPTS, DOCKER_NOT_RUNNING_MESSAGE, isContainerRunning, isDockerRunning, assertDockerRunning, areContainersRunning, getComposeArg, startContainers, stopContainers, startService, createBuiltInHealthCheck, waitForService, waitForAllServices, waitForServiceByType };