buncargo 1.0.26 → 3.0.0

package/dist/index-d8tyv5se.js

@@ -0,0 +1,228 @@
+import {
+  sleep
+} from "./index-c0dr6mcv.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 };

package/dist/index-d9efy0n4.js

@@ -3,176 +3,202 @@ import { execSync } from "node:child_process";
 import { readFileSync, unlinkSync } from "node:fs";
 import { join } from "node:path";
 import fg from "fast-glob";
+
 var DEFAULT_PATTERNS = ["apps/*", "packages/*", "modules"];
 var DEFAULT_CONCURRENCY = 1;
 var CORRUPTED_CACHE_PATTERNS = [
-  "all goroutines are asleep - deadlock",
-  "fatal error:",
-  "panic:",
-  "github.com/microsoft/typescript-go"
+	"all goroutines are asleep - deadlock",
+	"fatal error:",
+	"panic:",
+	"github.com/microsoft/typescript-go",
 ];
 function isCorruptedCacheError(output) {
-  return CORRUPTED_CACHE_PATTERNS.some((pattern) => output.includes(pattern));
+	return CORRUPTED_CACHE_PATTERNS.some((pattern) => output.includes(pattern));
 }
 async function clearTsBuildInfo(workspace, verbose) {
-  if (verbose) {
-    console.log(`\uD83E\uDDF9 Clearing corrupted tsbuildinfo cache for ${workspace}...`);
-  }
-  try {
-    const tsbuildInfoFiles = await fg(`${workspace}/**/*.tsbuildinfo`, {
-      absolute: true
-    });
-    for (const file of tsbuildInfoFiles) {
-      try {
-        unlinkSync(file);
-      } catch {}
-    }
-    const cacheFiles = await fg(`${workspace}/**/.cache/tsbuildinfo.json`, {
-      absolute: true
-    });
-    for (const file of cacheFiles) {
-      try {
-        unlinkSync(file);
-      } catch {}
-    }
-  } catch {}
+	if (verbose) {
+		console.log(
+			`\uD83E\uDDF9 Clearing corrupted tsbuildinfo cache for ${workspace}...`,
+		);
+	}
+	try {
+		const tsbuildInfoFiles = await fg(`${workspace}/**/*.tsbuildinfo`, {
+			absolute: true,
+		});
+		for (const file of tsbuildInfoFiles) {
+			try {
+				unlinkSync(file);
+			} catch {}
+		}
+		const cacheFiles = await fg(`${workspace}/**/.cache/tsbuildinfo.json`, {
+			absolute: true,
+		});
+		for (const file of cacheFiles) {
+			try {
+				unlinkSync(file);
+			} catch {}
+		}
+	} catch {}
 }
 async function countTypeScriptFiles(pkgPath, root) {
-  const files = await fg(`${pkgPath}/**/*.{ts,tsx}`, {
-    cwd: root,
-    ignore: ["**/node_modules/**"]
-  });
-  return files.length;
+	const files = await fg(`${pkgPath}/**/*.{ts,tsx}`, {
+		cwd: root,
+		ignore: ["**/node_modules/**"],
+	});
+	return files.length;
 }
 function formatErrorOutput(output) {
-  return output.split(`
-`).map((line) => {
-    return line.replace(/\.\.\/\.\.\/packages\/modules\//g, "").replace(/\((\d+),(\d+)\):?/g, ":$1:$2 -");
-  }).join(`
-`).trim();
+	return output
+		.split(`
+`)
+		.map((line) => {
+			return line
+				.replace(/\.\.\/\.\.\/packages\/modules\//g, "")
+				.replace(/\((\d+),(\d+)\):?/g, ":$1:$2 -");
+		})
+		.join(`
+`)
+		.trim();
 }
-async function runSingleTypecheck(workspace, fileCount, root, verbose, isRetry = false) {
-  const startTime = performance.now();
-  if (verbose) {
-    console.log(`Running typecheck in ${workspace} (${fileCount} files)${isRetry ? " (retry)" : ""}...`);
-  }
-  const workspacePath = join(root, workspace);
-  let success = false;
-  let stdout = "";
-  let stderr = "";
-  try {
-    const output = execSync("bun run typecheck", {
-      cwd: workspacePath,
-      encoding: "utf-8",
-      stdio: ["pipe", "pipe", "pipe"]
-    });
-    stdout = output ?? "";
-    success = true;
-  } catch (error) {
-    const execError = error;
-    stdout = execError.stdout ?? "";
-    stderr = execError.stderr ?? "";
-    success = false;
-  }
-  const duration = Number(((performance.now() - startTime) / 1000).toFixed(2));
-  let errorOutput;
-  if (!success) {
-    const parts = [stdout.trim(), stderr.trim()].filter(Boolean);
-    errorOutput = parts.length > 0 ? parts.join(`
-`) : undefined;
-    if (!isRetry && errorOutput && isCorruptedCacheError(errorOutput)) {
-      await clearTsBuildInfo(workspacePath, verbose);
-      return runSingleTypecheck(workspace, fileCount, root, verbose, true);
-    }
-  }
-  return { workspace, duration, success, fileCount, errorOutput };
+async function runSingleTypecheck(
+	workspace,
+	fileCount,
+	root,
+	verbose,
+	isRetry = false,
+) {
+	const startTime = performance.now();
+	if (verbose) {
+		console.log(
+			`Running typecheck in ${workspace} (${fileCount} files)${isRetry ? " (retry)" : ""}...`,
+		);
+	}
+	const workspacePath = join(root, workspace);
+	let success = false;
+	let stdout = "";
+	let stderr = "";
+	try {
+		const output = execSync("bun run typecheck", {
+			cwd: workspacePath,
+			encoding: "utf-8",
+			stdio: ["pipe", "pipe", "pipe"],
+		});
+		stdout = output ?? "";
+		success = true;
+	} catch (error) {
+		const execError = error;
+		stdout = execError.stdout ?? "";
+		stderr = execError.stderr ?? "";
+		success = false;
+	}
+	const duration = Number(((performance.now() - startTime) / 1000).toFixed(2));
+	let errorOutput;
+	if (!success) {
+		const parts = [stdout.trim(), stderr.trim()].filter(Boolean);
+		errorOutput =
+			parts.length > 0
+				? parts.join(`
+`)
+				: undefined;
+		if (!isRetry && errorOutput && isCorruptedCacheError(errorOutput)) {
+			await clearTsBuildInfo(workspacePath, verbose);
+			return runSingleTypecheck(workspace, fileCount, root, verbose, true);
+		}
+	}
+	return { workspace, duration, success, fileCount, errorOutput };
 }
 async function discoverWorkspaces(patterns, root) {
-  const workspaces = [];
-  for (const pattern of patterns) {
-    const matches = await fg(`${pattern}/package.json`, { cwd: root });
-    for (const match of matches) {
-      const pkgPath = match.replace("/package.json", "");
-      try {
-        const pkgJsonContent = readFileSync(join(root, match), "utf-8");
-        const pkgJson = JSON.parse(pkgJsonContent);
-        if (pkgJson.scripts?.typecheck) {
-          const fileCount = await countTypeScriptFiles(pkgPath, root);
-          workspaces.push({ path: pkgPath, fileCount });
-        }
-      } catch {}
-    }
-  }
-  workspaces.sort((a, b) => a.fileCount - b.fileCount);
-  return workspaces;
+	const workspaces = [];
+	for (const pattern of patterns) {
+		const matches = await fg(`${pattern}/package.json`, { cwd: root });
+		for (const match of matches) {
+			const pkgPath = match.replace("/package.json", "");
+			try {
+				const pkgJsonContent = readFileSync(join(root, match), "utf-8");
+				const pkgJson = JSON.parse(pkgJsonContent);
+				if (pkgJson.scripts?.typecheck) {
+					const fileCount = await countTypeScriptFiles(pkgPath, root);
+					workspaces.push({ path: pkgPath, fileCount });
+				}
+			} catch {}
+		}
+	}
+	workspaces.sort((a, b) => a.fileCount - b.fileCount);
+	return workspaces;
 }
 async function runWorkspaceTypecheck(options = {}) {
-  const {
-    root = process.cwd(),
-    patterns = DEFAULT_PATTERNS,
-    concurrency = DEFAULT_CONCURRENCY,
-    verbose = true
-  } = options;
-  const workspaces = await discoverWorkspaces(patterns, root);
-  if (workspaces.length === 0) {
-    if (verbose) {
-      console.log("No workspaces with typecheck script found.");
-    }
-    return {
-      success: true,
-      totalDuration: 0,
-      totalFiles: 0,
-      workspaceCount: 0,
-      results: []
-    };
-  }
-  const totalStartTime = performance.now();
-  if (verbose) {
-    console.log(`Running typecheck across ${workspaces.length} workspaces with concurrency limit of ${concurrency}...
+	const {
+		root = process.cwd(),
+		patterns = DEFAULT_PATTERNS,
+		concurrency = DEFAULT_CONCURRENCY,
+		verbose = true,
+	} = options;
+	const workspaces = await discoverWorkspaces(patterns, root);
+	if (workspaces.length === 0) {
+		if (verbose) {
+			console.log("No workspaces with typecheck script found.");
+		}
+		return {
+			success: true,
+			totalDuration: 0,
+			totalFiles: 0,
+			workspaceCount: 0,
+			results: [],
+		};
+	}
+	const totalStartTime = performance.now();
+	if (verbose) {
+		console.log(`Running typecheck across ${workspaces.length} workspaces with concurrency limit of ${concurrency}...
 `);
-  }
-  const results = [];
-  const running = new Set;
-  for (let i = 0;i < workspaces.length; i++) {
-    const { path, fileCount } = workspaces[i];
-    const promise = runSingleTypecheck(path, fileCount, root, verbose).then((result) => {
-      results[i] = result;
-      running.delete(promise);
-      if (verbose) {
-        const icon = result.success ? "✅" : "❌";
-        const log = result.success ? console.log : console.error;
-        log(`${icon} ${result.workspace} (${result.fileCount} files) ${result.success ? "completed" : "failed"} in ${result.duration.toFixed(2)}s`);
-        if (!result.success && result.errorOutput) {
-          console.error(`
+	}
+	const results = [];
+	const running = new Set();
+	for (let i = 0; i < workspaces.length; i++) {
+		const { path, fileCount } = workspaces[i];
+		const promise = runSingleTypecheck(path, fileCount, root, verbose).then(
+			(result) => {
+				results[i] = result;
+				running.delete(promise);
+				if (verbose) {
+					const icon = result.success ? "✅" : "❌";
+					const log = result.success ? console.log : console.error;
+					log(
+						`${icon} ${result.workspace} (${result.fileCount} files) ${result.success ? "completed" : "failed"} in ${result.duration.toFixed(2)}s`,
+					);
+					if (!result.success && result.errorOutput) {
+						console.error(`
 ${formatErrorOutput(result.errorOutput)}`);
-        }
-      }
-    });
-    running.add(promise);
-    if (running.size >= concurrency) {
-      await Promise.race(running);
-    }
-  }
-  await Promise.all(running);
-  const totalDuration = Number(((performance.now() - totalStartTime) / 1000).toFixed(2));
-  const totalFiles = workspaces.reduce((sum, w) => sum + w.fileCount, 0);
-  const success = results.every((r) => r.success);
-  if (verbose) {
-    if (success) {
-      console.log(`
+					}
+				}
+			},
+		);
+		running.add(promise);
+		if (running.size >= concurrency) {
+			await Promise.race(running);
+		}
+	}
+	await Promise.all(running);
+	const totalDuration = Number(
+		((performance.now() - totalStartTime) / 1000).toFixed(2),
+	);
+	const totalFiles = workspaces.reduce((sum, w) => sum + w.fileCount, 0);
+	const success = results.every((r) => r.success);
+	if (verbose) {
+		if (success) {
+			console.log(`
 All typecheck checks passed! Total time: ${totalDuration}s (${totalFiles} files)`);
-    } else {
-      console.error(`
+		} else {
+			console.error(`
 Typecheck failed. Total time: ${totalDuration}s`);
-    }
-  }
-  return {
-    success,
-    totalDuration,
-    totalFiles,
-    workspaceCount: workspaces.length,
-    results
-  };
+		}
+	}
+	return {
+		success,
+		totalDuration,
+		totalFiles,
+		workspaceCount: workspaces.length,
+		results,
+	};
 }
 
 export { runWorkspaceTypecheck };