buncargo 1.0.17 → 1.0.19

package/cli.ts

@@ -76,6 +76,12 @@ export async function runCli<
 		});
 		if (result.exitCode !== 0) {
 			console.error("❌ Seeding failed");
+			if (result.stderr) {
+				console.error(result.stderr);
+			}
+			if (result.stdout) {
+				console.error(result.stdout);
+			}
 			process.exit(1);
 		}
 		console.log("");

package/dist/bin.js

@@ -1,11 +1,11 @@
 #!/usr/bin/env bun
 import {
   runCli
-} from "./index-8hbbj1mp.js";
+} from "./index-7ja4ywyj.js";
 import {
   loadDevEnv
-} from "./index-qw4093g2.js";
-import"./index-2f47khe5.js";
+} from "./index-3h3dhtf2.js";
+import"./index-wz9x8g7z.js";
 import"./index-ggq3yryx.js";
 import"./index-1yvbwj4k.js";
 import"./index-tjqw9vtj.js";
@@ -22,7 +22,7 @@ import {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "buncargo",
-    version: "1.0.17",
+    version: "1.0.19",
     description: "A Bun-powered development environment CLI for managing Docker Compose services, dev servers, and environment variables",
     type: "module",
     module: "./dist/index.js",

package/dist/cli.js

@@ -2,7 +2,7 @@ import {
   getFlagValue,
   hasFlag,
   runCli
-} from "./index-8hbbj1mp.js";
+} from "./index-7ja4ywyj.js";
 import"./index-ggq3yryx.js";
 import"./index-1yvbwj4k.js";
 import"./index-qnx9j3qa.js";

package/dist/environment.js

@@ -1,6 +1,6 @@
 import {
   createDevEnvironment
-} from "./index-2f47khe5.js";
+} from "./index-wz9x8g7z.js";
 import"./index-ggq3yryx.js";
 import"./index-1yvbwj4k.js";
 import"./index-tjqw9vtj.js";

package/dist/index-3h3dhtf2.js

@@ -0,0 +1,58 @@
+import {
+  createDevEnvironment
+} from "./index-wz9x8g7z.js";
+
+// loader.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;
+  }
+}
+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({ ... })`);
+}
+function getDevEnv() {
+  if (!cachedEnv) {
+    throw new Error("Dev environment not loaded. Call loadDevEnv() first.");
+  }
+  return cachedEnv;
+}
+function clearDevEnvCache() {
+  cachedEnv = null;
+}
+
+export { CONFIG_FILES, findConfigFile, loadDevEnv, getDevEnv, clearDevEnvCache };

package/dist/index-7ja4ywyj.js

@@ -0,0 +1,142 @@
+import {
+  spawnWatchdog,
+  startHeartbeat,
+  stopHeartbeat
+} from "./index-ggq3yryx.js";
+import {
+  killProcessesOnAppPorts
+} from "./index-1yvbwj4k.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");
+      if (result.stderr) {
+        console.error(result.stderr);
+      }
+      if (result.stdout) {
+        console.error(result.stdout);
+      }
+      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 killProcessesOnAppPorts(env.apps, env.ports);
+  console.log("");
+  console.log("\uD83D\uDD27 Starting dev servers...");
+  console.log("");
+  await runCommand(command, env.root, env.buildEnvVars());
+  stopHeartbeat();
+}
+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) {
+  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);
+}
+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-wz9x8g7z.js

@@ -0,0 +1,394 @@
+import {
+  spawnWatchdog,
+  startHeartbeat,
+  stopHeartbeat,
+  stopWatchdog
+} from "./index-ggq3yryx.js";
+import {
+  buildApps,
+  execAsync,
+  startDevServers,
+  stopProcess
+} from "./index-1yvbwj4k.js";
+import {
+  assertValidConfig
+} from "./index-tjqw9vtj.js";
+import {
+  createPrismaRunner
+} from "./index-5hka0tff.js";
+import {
+  areContainersRunning,
+  startContainers,
+  stopContainers,
+  waitForAllServices
+} from "./index-2fr3g85b.js";
+import {
+  getLocalIp,
+  isCI,
+  logExpoApiUrl,
+  logFrontendPort,
+  waitForDevServers,
+  waitForServer
+} from "./index-6fm7mvwj.js";
+import {
+  calculatePortOffset,
+  computePorts,
+  computeUrls,
+  findMonorepoRoot,
+  getProjectName,
+  isWorktree
+} from "./index-08wa79cs.js";
+
+// environment.ts
+import pc from "picocolors";
+function formatUrl(url) {
+  return pc.cyan(url.replace(/:(\d+)(\/?)/, (_, port, slash) => `:${pc.bold(port)}${slash}`));
+}
+function formatLabel(label, value, arrow = "➜") {
+  return `  ${pc.green(arrow)}  ${pc.bold(label.padEnd(10))} ${value}`;
+}
+function formatDimLabel(label, value) {
+  return `  ${pc.dim("•")}  ${pc.dim(label.padEnd(10))} ${pc.dim(value)}`;
+}
+function createDevEnvironment(config, options = {}) {
+  assertValidConfig(config);
+  const root = findMonorepoRoot();
+  const suffix = options.suffix;
+  const worktree = isWorktree(root);
+  const portOffset = calculatePortOffset(suffix, root);
+  const projectName = getProjectName(config.projectPrefix, suffix, root);
+  const localIp = getLocalIp();
+  const services = config.services;
+  const apps = config.apps ?? {};
+  const ports = computePorts(services, apps, portOffset);
+  const urls = computeUrls(services, apps, ports, localIp);
+  function buildEnvVars(production = false) {
+    const baseEnv = {
+      COMPOSE_PROJECT_NAME: projectName,
+      NODE_ENV: production ? "production" : "development"
+    };
+    for (const [name, port] of Object.entries(ports)) {
+      const envName = `${name.toUpperCase()}_PORT`;
+      baseEnv[envName] = String(port);
+    }
+    for (const [name, url] of Object.entries(urls)) {
+      const envName = `${name.toUpperCase()}_URL`;
+      baseEnv[envName] = url;
+    }
+    if (config.envVars) {
+      const userEnv = config.envVars(ports, urls, {
+        projectName,
+        localIp,
+        portOffset
+      });
+      for (const [key, value] of Object.entries(userEnv)) {
+        baseEnv[key] = String(value);
+      }
+    }
+    return baseEnv;
+  }
+  let hookContext = null;
+  function getHookContext() {
+    if (!hookContext) {
+      hookContext = {
+        projectName,
+        ports,
+        urls,
+        root,
+        isCI: isCI(),
+        portOffset,
+        localIp,
+        exec: async (cmd, opts) => {
+          const envVars = buildEnvVars();
+          return execAsync(cmd, root, envVars, opts);
+        }
+      };
+    }
+    return hookContext;
+  }
+  function exec(cmd, options2) {
+    const envVars = buildEnvVars();
+    return execAsync(cmd, root, envVars, options2);
+  }
+  async function start(startOptions = {}) {
+    const isCI2 = process.env.CI === "true";
+    const {
+      verbose = config.options?.verbose ?? true,
+      wait = true,
+      startServers: shouldStartServers = true,
+      productionBuild = isCI2
+    } = startOptions;
+    const envVars = buildEnvVars(productionBuild);
+    if (verbose) {
+      logInfo(productionBuild ? "Production Environment" : "Dev Environment");
+    }
+    const serviceCount = Object.keys(services).length;
+    const alreadyRunning = await areContainersRunning(projectName, serviceCount);
+    if (alreadyRunning) {
+      if (verbose)
+        console.log("✓ Containers already running");
+    } else {
+      startContainers(root, projectName, envVars, {
+        verbose,
+        wait,
+        composeFile: config.options?.composeFile
+      });
+    }
+    if (wait) {
+      await waitForAllServices(services, ports, {
+        verbose,
+        projectName,
+        root
+      });
+    }
+    const allMigrations = [
+      ...config.prisma ? [
+        {
+          name: "prisma",
+          command: "bunx prisma migrate deploy",
+          cwd: config.prisma.cwd ?? "packages/prisma"
+        }
+      ] : [],
+      ...config.migrations ?? []
+    ];
+    if (allMigrations.length > 0) {
+      if (verbose)
+        console.log("\uD83D\uDCE6 Running migrations...");
+      const migrationResults = await Promise.all(allMigrations.map(async (migration) => {
+        const result = await exec(migration.command, {
+          cwd: migration.cwd,
+          throwOnError: false
+        });
+        return { name: migration.name, result };
+      }));
+      for (const { name, result } of migrationResults) {
+        if (result.exitCode !== 0) {
+          console.error(`❌ Migration "${name}" failed`);
+          console.error(result.stderr);
+          throw new Error(`Migration "${name}" failed`);
+        }
+      }
+      if (verbose)
+        console.log("✓ Migrations complete");
+    }
+    if (config.hooks?.afterContainersReady) {
+      await config.hooks.afterContainersReady(getHookContext());
+    }
+    if (config.seed) {
+      let shouldSeed = true;
+      if (config.seed.check) {
+        const checkTable = async (tableName, service) => {
+          const serviceName = service ?? "postgres";
+          const serviceUrl = urls[serviceName];
+          if (!serviceUrl) {
+            console.warn(`⚠️ Service "${serviceName}" not found for checkTable`);
+            return true;
+          }
+          const checkResult = await exec(`psql "${serviceUrl}" -tAc 'SELECT COUNT(*) FROM "${tableName}" LIMIT 1'`, { throwOnError: false });
+          const count = checkResult.stdout.trim();
+          const shouldSeed2 = checkResult.exitCode !== 0 || count === "0" || count === "";
+          if (!shouldSeed2) {
+            console.log(`  \uD83D\uDCCA Table "${tableName}" has ${count} rows`);
+          }
+          return shouldSeed2;
+        };
+        const seedCheckContext = {
+          ...getHookContext(),
+          checkTable
+        };
+        shouldSeed = await config.seed.check(seedCheckContext);
+      }
+      if (shouldSeed) {
+        if (verbose)
+          console.log("\uD83C\uDF31 Running seeders...");
+        const seedResult = await exec(config.seed.command, {
+          cwd: config.seed.cwd,
+          verbose,
+          throwOnError: false
+        });
+        if (seedResult.exitCode !== 0) {
+          console.error("❌ Seeding failed");
+          console.error(seedResult.stderr);
+        } else {
+          if (verbose)
+            console.log("✓ Seeding complete");
+        }
+      } else {
+        if (verbose)
+          console.log("✓ Database already has data, skipping seeders");
+      }
+    }
+    if (shouldStartServers && Object.keys(apps).length > 0) {
+      if (config.hooks?.beforeServers) {
+        await config.hooks.beforeServers(getHookContext());
+      }
+      if (productionBuild) {
+        buildApps(apps, root, envVars, { verbose });
+      }
+      const pids = await startDevServers(apps, root, envVars, ports, {
+        verbose,
+        productionBuild,
+        isCI: isCI2
+      });
+      if (verbose)
+        console.log("⏳ Waiting for servers to be ready...");
+      await waitForDevServers(apps, ports, {
+        timeout: isCI2 ? 120000 : 60000,
+        verbose,
+        productionBuild
+      });
+      if (config.hooks?.afterServers) {
+        await config.hooks.afterServers(getHookContext());
+      }
+      if (verbose)
+        console.log(`✅ Environment ready
+`);
+      return pids;
+    }
+    if (verbose)
+      console.log(`✅ Containers ready
+`);
+    return null;
+  }
+  async function stop(stopOptions = {}) {
+    const { verbose = true, removeVolumes = false } = stopOptions;
+    if (config.hooks?.beforeStop) {
+      await config.hooks.beforeStop(getHookContext());
+    }
+    stopContainers(root, projectName, {
+      verbose,
+      removeVolumes,
+      composeFile: config.options?.composeFile
+    });
+  }
+  async function restart() {
+    await stop();
+    await start({ startServers: false });
+  }
+  async function isRunning() {
+    const serviceCount = Object.keys(services).length;
+    return areContainersRunning(projectName, serviceCount);
+  }
+  async function startServersOnly(options2 = {}) {
+    const { productionBuild = false, verbose = true } = options2;
+    const envVars = buildEnvVars(productionBuild);
+    const isCI2 = process.env.CI === "true";
+    if (productionBuild) {
+      buildApps(apps, root, envVars, { verbose });
+    }
+    return startDevServers(apps, root, envVars, ports, {
+      verbose,
+      productionBuild,
+      isCI: isCI2
+    });
+  }
+  async function waitForServersReady(options2 = {}) {
+    const { timeout = 60000, productionBuild = false } = options2;
+    await waitForDevServers(apps, ports, { timeout, productionBuild });
+  }
+  function logInfo(label = "Docker Dev") {
+    const serviceNames = Object.keys(services);
+    const appNames = Object.keys(apps);
+    console.log("");
+    console.log(`  ${pc.cyan(pc.bold(`\uD83D\uDC33 ${label}`))}`);
+    console.log(formatLabel("Project:", pc.white(projectName)));
+    if (serviceNames.length > 0) {
+      console.log("");
+      console.log(`  ${pc.dim("─── Services ───")}`);
+      for (const name of serviceNames) {
+        const port = ports[name];
+        const url = `localhost:${port}`;
+        console.log(formatLabel(`${name}:`, formatUrl(`http://${url}`)));
+      }
+    }
+    if (appNames.length > 0) {
+      console.log("");
+      console.log(`  ${pc.dim("─── Applications ───")}`);
+      for (const name of appNames) {
+        const port = ports[name];
+        const localUrl = `http://localhost:${port}`;
+        const networkUrl = `http://${localIp}:${port}`;
+        console.log(`  ${pc.green("➜")}  ${pc.bold(pc.cyan(name))}`);
+        console.log(`       ${pc.dim("Local:")}   ${formatUrl(localUrl)}`);
+        console.log(`       ${pc.dim("Network:")} ${formatUrl(networkUrl)}`);
+      }
+    }
+    console.log("");
+    console.log(`  ${pc.dim("─── Environment ───")}`);
+    console.log(formatDimLabel("Worktree:", worktree ? "yes" : "no"));
+    console.log(formatDimLabel("Port offset:", portOffset > 0 ? `+${portOffset}` : "none"));
+    if (suffix) {
+      console.log(formatDimLabel("Suffix:", suffix));
+    }
+    console.log(formatDimLabel("Local IP:", localIp));
+    console.log("");
+  }
+  async function waitForServerUrl(url, timeout) {
+    await waitForServer(url, { timeout });
+  }
+  function startHeartbeat2(intervalMs) {
+    startHeartbeat(projectName, intervalMs);
+  }
+  function stopHeartbeat2() {
+    stopHeartbeat();
+  }
+  async function spawnWatchdog2(timeoutMinutes) {
+    await spawnWatchdog(projectName, root, {
+      timeoutMinutes,
+      verbose: true,
+      composeFile: config.options?.composeFile
+    });
+  }
+  function stopWatchdog2() {
+    stopWatchdog(projectName);
+  }
+  function getExpoApiUrl() {
+    const apiPort = ports.api;
+    const url = `http://${localIp}:${apiPort}`;
+    logExpoApiUrl(url);
+    return url;
+  }
+  function getFrontendPort() {
+    const port = ports.platform;
+    logFrontendPort(port);
+    return port;
+  }
+  function withSuffix(newSuffix) {
+    return createDevEnvironment(config, { suffix: newSuffix });
+  }
+  const env = {
+    projectName,
+    ports,
+    urls,
+    apps,
+    portOffset,
+    isWorktree: worktree,
+    localIp,
+    root,
+    start,
+    stop,
+    restart,
+    isRunning,
+    startServers: startServersOnly,
+    stopProcess,
+    waitForServers: waitForServersReady,
+    buildEnvVars,
+    exec,
+    waitForServer: waitForServerUrl,
+    logInfo,
+    getExpoApiUrl,
+    getFrontendPort,
+    startHeartbeat: startHeartbeat2,
+    stopHeartbeat: stopHeartbeat2,
+    spawnWatchdog: spawnWatchdog2,
+    stopWatchdog: stopWatchdog2,
+    prisma: undefined,
+    withSuffix
+  };
+  if (config.prisma) {
+    env.prisma = createPrismaRunner(env, config.prisma);
+  }
+  return env;
+}
+
+export { createDevEnvironment };

package/dist/index.js

@@ -2,7 +2,7 @@ import {
   getFlagValue,
   hasFlag,
   runCli
-} from "./index-8hbbj1mp.js";
+} from "./index-7ja4ywyj.js";
 import {
   runWorkspaceTypecheck
 } from "./index-d9efy0n4.js";
@@ -10,10 +10,10 @@ import {
   clearDevEnvCache,
   getDevEnv,
   loadDevEnv
-} from "./index-qw4093g2.js";
+} from "./index-3h3dhtf2.js";
 import {
   createDevEnvironment
-} from "./index-2f47khe5.js";
+} from "./index-wz9x8g7z.js";
 import {
   getHeartbeatFile,
   getWatchdogPidFile,

package/dist/loader.js

@@ -4,8 +4,8 @@ import {
   findConfigFile,
   getDevEnv,
   loadDevEnv
-} from "./index-qw4093g2.js";
-import"./index-2f47khe5.js";
+} from "./index-3h3dhtf2.js";
+import"./index-wz9x8g7z.js";
 import"./index-ggq3yryx.js";
 import"./index-1yvbwj4k.js";
 import"./index-tjqw9vtj.js";

package/environment.ts

@@ -299,12 +299,16 @@ export function createDevEnvironment<
 						console.warn(`⚠️ Service "${serviceName}" not found for checkTable`);
 						return true; // Default to seeding if service not found
 					}
-					const checkResult = await exec(
-						`psql "${serviceUrl}" -tAc 'SELECT COUNT(*) FROM "${tableName}" LIMIT 1'`,
-						{ throwOnError: false },
-					);
-					const count = checkResult.stdout.trim();
-					return checkResult.exitCode !== 0 || count === "0" || count === "";
+				const checkResult = await exec(
+					`psql "${serviceUrl}" -tAc 'SELECT COUNT(*) FROM "${tableName}" LIMIT 1'`,
+					{ throwOnError: false },
+				);
+				const count = checkResult.stdout.trim();
+				const shouldSeed = checkResult.exitCode !== 0 || count === "0" || count === "";
+				if (!shouldSeed) {
+					console.log(`  📊 Table "${tableName}" has ${count} rows`);
+				}
+				return shouldSeed;
 				};
 
 				// Build seed check context with helpers

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buncargo",
-  "version": "1.0.17",
+  "version": "1.0.19",
   "description": "A Bun-powered development environment CLI for managing Docker Compose services, dev servers, and environment variables",
   "type": "module",
   "module": "./dist/index.js",