buncargo 1.0.26 → 1.0.29

package/bin.ts

@@ -186,6 +186,7 @@ async function main(): Promise<void> {
 }
 
 main().catch((error) => {
-	console.error("❌ Fatal error:", error);
+	const message = error instanceof Error ? error.message : String(error);
+	console.error(`❌ ${message}`);
 	process.exit(1);
 });

package/core/docker.ts

@@ -12,6 +12,8 @@ import { sleep } from "./utils";
 
 export const POLL_INTERVAL = 250; // Fast polling for quicker startup
 export const MAX_ATTEMPTS = 120; // 30 seconds total (120 * 250ms)
+export const DOCKER_NOT_RUNNING_MESSAGE =
+	"Docker is not running. Please start Docker and try again.";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Container Status Checks
@@ -35,6 +37,30 @@ export async function isContainerRunning(
 	}
 }
 
+/**
+ * Check if Docker daemon is running and reachable.
+ */
+export function isDockerRunning(): boolean {
+	try {
+		execSync('docker info --format "{{.ServerVersion}}"', {
+			encoding: "utf-8",
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+		return true;
+	} catch {
+		return false;
+	}
+}
+
+/**
+ * Ensure Docker is running before attempting compose operations.
+ */
+export function assertDockerRunning(): void {
+	if (!isDockerRunning()) {
+		throw new Error(DOCKER_NOT_RUNNING_MESSAGE);
+	}
+}
+
 /**
  * Check if all expected containers are running.
  */
@@ -75,6 +101,7 @@ export function startContainers(
 	options: StartContainersOptions = {},
 ): void {
 	const { verbose = true, wait = true, composeFile } = options;
+	assertDockerRunning();
 
 	if (verbose) console.log("🐳 Starting Docker containers...");
 
@@ -106,6 +133,7 @@ export function stopContainers(
 	options: StopContainersOptions = {},
 ): void {
 	const { verbose = true, removeVolumes = false, composeFile } = options;
+	assertDockerRunning();
 
 	if (verbose) {
 		console.log(
@@ -139,6 +167,7 @@ export function startService(
 	options: { verbose?: boolean; composeFile?: string } = {},
 ): void {
 	const { verbose = true, composeFile } = options;
+	assertDockerRunning();
 
 	if (verbose) console.log(`🐳 Starting ${serviceName}...`);
 

package/core/ports.ts

@@ -57,6 +57,28 @@ export function isWorktree(root?: string): boolean {
 	return getWorktreeName(root) !== null;
 }
 
+/**
+ * Sanitize a string for use as a Docker Compose project suffix.
+ */
+function sanitizeProjectSuffix(value: string): string {
+	return value
+		.toLowerCase()
+		.replace(/[^a-z0-9-]/g, "-")
+		.replace(/-+/g, "-")
+		.replace(/^-+|-+$/g, "");
+}
+
+/**
+ * Get a sanitized worktree-derived suffix for Docker project isolation.
+ * Returns null when not running in a worktree.
+ */
+export function getWorktreeProjectSuffix(root?: string): string | null {
+	const worktreeName = getWorktreeName(root);
+	if (!worktreeName) return null;
+	const sanitized = sanitizeProjectSuffix(worktreeName);
+	return sanitized || "worktree";
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Port Offset Calculation
 // ═══════════════════════════════════════════════════════════════════════════
@@ -104,6 +126,48 @@ export function getProjectName(
 	return suffix ? `${baseName}-${suffix}` : baseName;
 }
 
+export interface DevIdentityOptions {
+	projectPrefix: string;
+	suffix?: string;
+	root?: string;
+	worktreeIsolation?: boolean;
+}
+
+export interface DevIdentity {
+	worktree: boolean;
+	worktreeSuffix: string | null;
+	projectSuffix?: string;
+	projectName: string;
+	portOffset: number;
+}
+
+/**
+ * Compute all identity values used by the dev environment in one place.
+ */
+export function computeDevIdentity(options: DevIdentityOptions): DevIdentity {
+	const {
+		projectPrefix,
+		suffix,
+		root: providedRoot,
+		worktreeIsolation = true,
+	} = options;
+	const root = providedRoot ?? findMonorepoRoot();
+	const worktree = isWorktree(root);
+	const worktreeSuffix =
+		worktree && worktreeIsolation ? getWorktreeProjectSuffix(root) : null;
+	const projectSuffix = [suffix, worktreeSuffix].filter(Boolean).join("-") || undefined;
+	const projectName = getProjectName(projectPrefix, projectSuffix, root);
+	const portOffset = calculatePortOffset(suffix, root);
+
+	return {
+		worktree,
+		worktreeSuffix,
+		projectSuffix,
+		projectName,
+		portOffset,
+	};
+}
+
 // ═══════════════════════════════════════════════════════════════════════════
 // Port Computation
 // ═══════════════════════════════════════════════════════════════════════════

package/dist/bin.js

@@ -4,15 +4,15 @@ import {
 } from "./index-segbnm0h.js";
 import {
   loadDevEnv
-} from "./index-42x95209.js";
-import"./index-p8wty0e2.js";
+} from "./index-1mdrf7nz.js";
+import"./index-wk2na3t9.js";
 import"./index-ggq3yryx.js";
 import"./index-1yvbwj4k.js";
 import"./index-tjqw9vtj.js";
-import"./index-5hka0tff.js";
-import"./index-2fr3g85b.js";
-import"./index-6fm7mvwj.js";
-import"./index-08wa79cs.js";
+import"./index-qfphr2fd.js";
+import"./index-zfjzzjkf.js";
+import"./index-8xj2p5n5.js";
+import"./index-731rzzfp.js";
 import {
   __commonJS,
   __require
@@ -22,7 +22,7 @@ import {
 var require_package = __commonJS((exports, module) => {
   module.exports = {
     name: "buncargo",
-    version: "1.0.26",
+    version: "1.0.29",
     description: "A Bun-powered development environment CLI for managing Docker Compose services, dev servers, and environment variables",
     type: "module",
     module: "./dist/index.js",
@@ -295,6 +295,7 @@ async function main() {
   }
 }
 main().catch((error) => {
-  console.error("❌ Fatal error:", error);
+  const message = error instanceof Error ? error.message : String(error);
+  console.error(`❌ ${message}`);
   process.exit(1);
 });

package/dist/core/docker.d.ts

@@ -1,10 +1,19 @@
 import type { BuiltInHealthCheck, HealthCheckFn, ServiceConfig } from "../types";
 export declare const POLL_INTERVAL = 250;
 export declare const MAX_ATTEMPTS = 120;
+export declare const DOCKER_NOT_RUNNING_MESSAGE = "Docker is not running. Please start Docker and try again.";
 /**
  * Check if a specific container service is running using docker ps.
  */
 export declare function isContainerRunning(project: string, service: string): Promise<boolean>;
+/**
+ * Check if Docker daemon is running and reachable.
+ */
+export declare function isDockerRunning(): boolean;
+/**
+ * Ensure Docker is running before attempting compose operations.
+ */
+export declare function assertDockerRunning(): void;
 /**
  * Check if all expected containers are running.
  */

package/dist/core/docker.js

@@ -1,18 +1,21 @@
 import {
+  DOCKER_NOT_RUNNING_MESSAGE,
   MAX_ATTEMPTS,
   POLL_INTERVAL,
   areContainersRunning,
+  assertDockerRunning,
   createBuiltInHealthCheck,
   isContainerRunning,
+  isDockerRunning,
   startContainers,
   startService,
   stopContainers,
   waitForAllServices,
   waitForService,
   waitForServiceByType
-} from "../index-2fr3g85b.js";
-import"../index-6fm7mvwj.js";
-import"../index-08wa79cs.js";
+} from "../index-zfjzzjkf.js";
+import"../index-8xj2p5n5.js";
+import"../index-731rzzfp.js";
 import"../index-qnx9j3qa.js";
 export {
   waitForServiceByType,
@@ -21,9 +24,12 @@ export {
   stopContainers,
   startService,
   startContainers,
+  isDockerRunning,
   isContainerRunning,
   createBuiltInHealthCheck,
+  assertDockerRunning,
   areContainersRunning,
   POLL_INTERVAL,
-  MAX_ATTEMPTS
+  MAX_ATTEMPTS,
+  DOCKER_NOT_RUNNING_MESSAGE
 };

package/dist/core/index.js

@@ -26,18 +26,21 @@ import {
   stopProcess
 } from "../index-1yvbwj4k.js";
 import {
+  DOCKER_NOT_RUNNING_MESSAGE,
   MAX_ATTEMPTS,
   POLL_INTERVAL,
   areContainersRunning,
+  assertDockerRunning,
   createBuiltInHealthCheck,
   isContainerRunning,
+  isDockerRunning,
   startContainers,
   startService,
   stopContainers,
   waitForAllServices,
   waitForService,
   waitForServiceByType
-} from "../index-2fr3g85b.js";
+} from "../index-zfjzzjkf.js";
 import {
   getEnvVar,
   getLocalIp,
@@ -49,16 +52,18 @@ import {
   sleep,
   waitForDevServers,
   waitForServer
-} from "../index-6fm7mvwj.js";
+} from "../index-8xj2p5n5.js";
 import {
   calculatePortOffset,
+  computeDevIdentity,
   computePorts,
   computeUrls,
   findMonorepoRoot,
   getProjectName,
   getWorktreeName,
+  getWorktreeProjectSuffix,
   isWorktree
-} from "../index-08wa79cs.js";
+} from "../index-731rzzfp.js";
 import"../index-qnx9j3qa.js";
 export {
   waitForServiceByType,
@@ -91,8 +96,10 @@ export {
   isProcessAlive,
   isPortInUse,
   isPortAvailable,
+  isDockerRunning,
   isContainerRunning,
   isCI,
+  getWorktreeProjectSuffix,
   getWorktreeName,
   getWatchdogPidFile,
   getWatchdogPid,
@@ -107,9 +114,12 @@ export {
   createBuiltInHealthCheck,
   computeUrls,
   computePorts,
+  computeDevIdentity,
   calculatePortOffset,
   buildApps,
+  assertDockerRunning,
   areContainersRunning,
   POLL_INTERVAL,
-  MAX_ATTEMPTS
+  MAX_ATTEMPTS,
+  DOCKER_NOT_RUNNING_MESSAGE
 };

package/dist/core/network.js

@@ -3,8 +3,8 @@ import {
   isPortAvailable,
   waitForDevServers,
   waitForServer
-} from "../index-6fm7mvwj.js";
-import"../index-08wa79cs.js";
+} from "../index-8xj2p5n5.js";
+import"../index-731rzzfp.js";
 import"../index-qnx9j3qa.js";
 export {
   waitForServer,

package/dist/core/ports.d.ts

@@ -11,6 +11,11 @@ export declare function getWorktreeName(root?: string): string | null;
  * Check if the current directory is a git worktree.
  */
 export declare function isWorktree(root?: string): boolean;
+/**
+ * Get a sanitized worktree-derived suffix for Docker project isolation.
+ * Returns null when not running in a worktree.
+ */
+export declare function getWorktreeProjectSuffix(root?: string): string | null;
 /**
  * Calculate port offset based on worktree name and optional suffix.
  * Returns 0 for main branch, 10-99 for worktrees.
@@ -20,6 +25,23 @@ export declare function calculatePortOffset(suffix?: string, root?: string): num
  * Generate Docker project name from prefix and directory.
  */
 export declare function getProjectName(prefix: string, suffix?: string, root?: string): string;
+export interface DevIdentityOptions {
+    projectPrefix: string;
+    suffix?: string;
+    root?: string;
+    worktreeIsolation?: boolean;
+}
+export interface DevIdentity {
+    worktree: boolean;
+    worktreeSuffix: string | null;
+    projectSuffix?: string;
+    projectName: string;
+    portOffset: number;
+}
+/**
+ * Compute all identity values used by the dev environment in one place.
+ */
+export declare function computeDevIdentity(options: DevIdentityOptions): DevIdentity;
 /**
  * Compute all ports for services and apps with offset applied.
  */

package/dist/core/ports.js

@@ -1,19 +1,23 @@
 import {
   calculatePortOffset,
+  computeDevIdentity,
   computePorts,
   computeUrls,
   findMonorepoRoot,
   getProjectName,
   getWorktreeName,
+  getWorktreeProjectSuffix,
   isWorktree
-} from "../index-08wa79cs.js";
+} from "../index-731rzzfp.js";
 import"../index-qnx9j3qa.js";
 export {
   isWorktree,
+  getWorktreeProjectSuffix,
   getWorktreeName,
   getProjectName,
   findMonorepoRoot,
   computeUrls,
   computePorts,
+  computeDevIdentity,
   calculatePortOffset
 };

package/dist/core/utils.js

@@ -5,8 +5,8 @@ import {
   logExpoApiUrl,
   logFrontendPort,
   sleep
-} from "../index-6fm7mvwj.js";
-import"../index-08wa79cs.js";
+} from "../index-8xj2p5n5.js";
+import"../index-731rzzfp.js";
 import"../index-qnx9j3qa.js";
 export {
   sleep,

package/dist/environment.js

@@ -1,13 +1,13 @@
 import {
   createDevEnvironment
-} from "./index-p8wty0e2.js";
+} from "./index-wk2na3t9.js";
 import"./index-ggq3yryx.js";
 import"./index-1yvbwj4k.js";
 import"./index-tjqw9vtj.js";
-import"./index-5hka0tff.js";
-import"./index-2fr3g85b.js";
-import"./index-6fm7mvwj.js";
-import"./index-08wa79cs.js";
+import"./index-qfphr2fd.js";
+import"./index-zfjzzjkf.js";
+import"./index-8xj2p5n5.js";
+import"./index-731rzzfp.js";
 import"./index-qnx9j3qa.js";
 export {
   createDevEnvironment

package/dist/index-1mdrf7nz.js

@@ -0,0 +1,58 @@
+import {
+  createDevEnvironment
+} from "./index-wk2na3t9.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-731rzzfp.js

@@ -0,0 +1,172 @@
+// 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();
+}
+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;
+  }
+}
+function isWorktree(root) {
+  return getWorktreeName(root) !== null;
+}
+function sanitizeProjectSuffix(value) {
+  return value.toLowerCase().replace(/[^a-z0-9-]/g, "-").replace(/-+/g, "-").replace(/^-+|-+$/g, "");
+}
+function getWorktreeProjectSuffix(root) {
+  const worktreeName = getWorktreeName(root);
+  if (!worktreeName)
+    return null;
+  const sanitized = sanitizeProjectSuffix(worktreeName);
+  return sanitized || "worktree";
+}
+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);
+}
+function calculatePortOffset(suffix, root) {
+  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;
+}
+function computeDevIdentity(options) {
+  const {
+    projectPrefix,
+    suffix,
+    root: providedRoot,
+    worktreeIsolation = true
+  } = options;
+  const root = providedRoot ?? findMonorepoRoot();
+  const worktree = isWorktree(root);
+  const worktreeSuffix = worktree && worktreeIsolation ? getWorktreeProjectSuffix(root) : null;
+  const projectSuffix = [suffix, worktreeSuffix].filter(Boolean).join("-") || undefined;
+  const projectName = getProjectName(projectPrefix, projectSuffix, root);
+  const portOffset = calculatePortOffset(suffix, root);
+  return {
+    worktree,
+    worktreeSuffix,
+    projectSuffix,
+    projectName,
+    portOffset
+  };
+}
+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;
+}
+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: "" }
+};
+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;
+  }
+}
+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;
+}
+
+export { findMonorepoRoot, getWorktreeName, isWorktree, getWorktreeProjectSuffix, calculatePortOffset, getProjectName, computeDevIdentity, computePorts, computeUrls };