buncargo 1.0.26 → 3.0.0

package/dist/index-xkvd0nsd.js

@@ -0,0 +1,187 @@
+// src/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,
+};

package/dist/index-yedqxm1z.js

@@ -0,0 +1,80 @@
+import { createDevEnvironment } from "./index-38xnzpa6.js";
+
+// src/loader/cache.ts
+var cachedEnv = null;
+function setCachedDevEnv(env) {
+	cachedEnv = env;
+}
+function getCachedDevEnv() {
+	return cachedEnv;
+}
+function clearDevEnvCache() {
+	cachedEnv = null;
+}
+
+// src/loader/find-config-file.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;
+	}
+}
+// src/loader/load-dev-env.ts
+async function loadDevEnv(options) {
+	if (!options?.reload) {
+		const cached = getCachedDevEnv();
+		if (cached) return cached;
+	}
+	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.`,
+			);
+		}
+		const env = createDevEnvironment(config);
+		setCachedDevEnv(env);
+		return env;
+	}
+	throw new Error(
+		"No config file found. Create dev.config.ts with: export default defineDevConfig({ ... })",
+	);
+}
+
+// src/loader/index.ts
+function getDevEnv() {
+	const env = getCachedDevEnv();
+	if (!env) {
+		throw new Error("Dev environment not loaded. Call loadDevEnv() first.");
+	}
+	return env;
+}
+export {
+	clearDevEnvCache,
+	CONFIG_FILES,
+	findConfigFile,
+	loadDevEnv,
+	getDevEnv,
+};

package/dist/index-zfjzzjkf.js

@@ -0,0 +1,266 @@
+// core/docker.ts
+import { execSync } from "node:child_process";
+import { sleep } from "./index-8xj2p5n5.js";
+
+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 startContainers(root, projectName, envVars, options = {}) {
+	const { verbose = true, wait = true, composeFile } = options;
+	assertDockerRunning();
+	if (verbose) console.log("\uD83D\uDC33 Starting Docker containers...");
+	const composeArg = composeFile ? `-f ${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 = composeFile ? `-f ${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 = composeFile ? `-f ${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,
+	startContainers,
+	stopContainers,
+	startService,
+	createBuiltInHealthCheck,
+	waitForService,
+	waitForAllServices,
+	waitForServiceByType,
+};

package/dist/index.d.ts

@@ -1,12 +1,16 @@
-export { getFlagValue, hasFlag, runCli } from "./cli";
-export { assertValidConfig, defineDevConfig, mergeConfigs, validateConfig, } from "./config";
-export { createDevEnvironment } from "./environment";
-export { runWorkspaceTypecheck, type TypecheckResult, type WorkspaceTypecheckOptions, type WorkspaceTypecheckResult, } from "./lint";
-export { clearDevEnvCache, getDevEnv, loadDevEnv } from "./loader";
-export type { AppConfig, BuiltInHealthCheck, CliOptions, ComputedPorts, ComputedUrls, DevConfig, DevEnvironment, DevHooks, DevOptions, DevServerPids, EnvVarsBuilder, ExecOptions, HealthCheckFn, HookContext, MigrationConfig, PrismaConfig, PrismaRunner, SeedCheckContext, SeedCheckHelpers, SeedConfig, ServiceConfig, StartOptions, StopOptions, UrlBuilderContext, UrlBuilderFn, } from "./types";
-export { areContainersRunning, isContainerRunning, MAX_ATTEMPTS, POLL_INTERVAL, } from "./core/docker";
+export { getFlagValue, hasFlag, runCli } from "./cli/run-cli";
+export { assertValidConfig, defineDevConfig, mergeConfigs, validateConfig, } from "./config/index";
+export type { ClickhouseServiceOptions, CustomServiceOptions, PostgresServiceOptions, RedisServiceOptions, } from "./docker-compose/services";
+export { service } from "./docker-compose/services";
+export { createDevEnvironment } from "./environment/index";
+export { clearDevEnvCache, getDevEnv, loadDevEnv } from "./loader/index";
+export { runWorkspaceTypecheck, type TypecheckResult, type WorkspaceTypecheckOptions, type WorkspaceTypecheckResult, } from "./typecheck/index";
+export type { AppConfig, BuiltInHealthCheck, CliOptions, ComputedPorts, ComputedPublicUrls, ComputedUrls, DevConfig, DevEnvironment, DevHooks, DevOptions, DevServerPids, DockerComposeGenerationOptions, DockerComposeHealthcheckRaw, DockerComposeNode, DockerComposeServiceRaw, DockerComposeVolumeRaw, DockerPresetName, DockerPresetServiceDefinition, DockerServiceDefinition, EnvVarsBuilder, ExecOptions, HealthCheckFn, HookContext, MigrationConfig, PrismaConfig, PrismaRunner, SeedCheckContext, SeedCheckHelpers, SeedConfig, ServiceConfig, StartOptions, StopOptions, UrlBuilderContext, UrlBuilderFn, } from "./types/index";
 export { getLocalIp, isPortAvailable, waitForServer } from "./core/network";
-export { calculatePortOffset, findMonorepoRoot, getProjectName, getWorktreeName, isWorktree, } from "./core/ports";
+export { calculatePortOffset, computeDevIdentity, findMonorepoRoot, getProjectName, getWorktreeName, getWorktreeProjectSuffix, isWorktree, } from "./core/ports";
 export { getProcessOnPort, isPortInUse, isProcessAlive, killProcessesOnAppPorts, killProcessOnPort, killProcessOnPortAndWait, } from "./core/process";
+export { type PublicExposeTarget, type PublicTunnel, resolveExposeTargets, startPublicTunnels, stopPublicTunnels, } from "./core/tunnel";
 export { getEnvVar, isCI, logApiUrl, logExpoApiUrl, logFrontendPort, sleep, } from "./core/utils";
 export { getHeartbeatFile, getWatchdogPidFile, isWatchdogRunning, spawnWatchdog, startHeartbeat, stopHeartbeat, stopWatchdog, } from "./core/watchdog";
+export { areContainersRunning, assertDockerRunning, DOCKER_NOT_RUNNING_MESSAGE, isContainerRunning, isDockerRunning, MAX_ATTEMPTS, POLL_INTERVAL, } from "./docker/index";
+export { buildComposeModel, composeToYaml, DEFAULT_GENERATED_COMPOSE_FILE, getGeneratedComposePath, writeGeneratedComposeFile, } from "./docker-compose/index";