buncargo 1.0.29 → 3.2.0

package/src/environment/logging.ts

@@ -0,0 +1,115 @@
+import pc from "picocolors";
+
+function formatUrl(url: string): string {
+	return pc.cyan(
+		url.replace(/:(\d+)(\/?)/, (_, port, slash) => `:${pc.bold(port)}${slash}`),
+	);
+}
+
+function formatLabel(label: string, value: string, arrow = "➜"): string {
+	return `  ${pc.green(arrow)}  ${pc.bold(label.padEnd(10))} ${value}`;
+}
+
+function formatDimLabel(label: string, value: string): string {
+	return `  ${pc.dim("•")}  ${pc.dim(label.padEnd(10))} ${pc.dim(value)}`;
+}
+
+function tunnelFor(
+	tunnels:
+		| Array<{
+				kind: "service" | "app";
+				name: string;
+				publicUrl: string;
+				localUrl: string;
+		  }>
+		| undefined,
+	name: string,
+	kind: "service" | "app",
+) {
+	return tunnels?.find((t) => t.name === name && t.kind === kind);
+}
+
+export function logEnvironmentInfo(input: {
+	label: string;
+	projectName: string;
+	services: Record<string, unknown>;
+	apps: Record<string, unknown>;
+	ports: Record<string, number>;
+	localIp: string;
+	worktree: boolean;
+	portOffset: number;
+	projectSuffix?: string;
+	tunnels?: Array<{
+		kind: "service" | "app";
+		name: string;
+		publicUrl: string;
+		localUrl: string;
+	}>;
+}): void {
+	const {
+		label,
+		projectName,
+		services,
+		apps,
+		ports,
+		localIp,
+		worktree,
+		portOffset,
+		projectSuffix,
+		tunnels,
+	} = input;
+	const serviceNames = Object.keys(services);
+	const appNames = Object.keys(apps);
+
+	console.log("");
+	console.log(`  ${pc.cyan(pc.bold(`🐳 ${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}`)));
+			const t = tunnelFor(tunnels, name, "service");
+			if (t) {
+				console.log(
+					`       ${pc.dim("Public:")}  ${formatUrl(t.publicUrl)} ${pc.dim("(tunnel)")}`,
+				);
+			}
+		}
+	}
+
+	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)}`);
+			const t = tunnelFor(tunnels, name, "app");
+			if (t) {
+				console.log(
+					`       ${pc.dim("Public:")}  ${formatUrl(t.publicUrl)} ${pc.dim("(tunnel)")}`,
+				);
+			}
+		}
+	}
+
+	console.log("");
+	console.log(`  ${pc.dim("─── Environment ───")}`);
+	console.log(formatDimLabel("Worktree:", worktree ? "yes" : "no"));
+	console.log(
+		formatDimLabel("Port offset:", portOffset > 0 ? `+${portOffset}` : "none"),
+	);
+	if (projectSuffix) {
+		console.log(formatDimLabel("Suffix:", projectSuffix));
+	}
+	console.log(formatDimLabel("Local IP:", localIp));
+	console.log("");
+}

package/src/environment/only-apps.ts

@@ -0,0 +1,34 @@
+import type { AppConfig } from "../types";
+
+/**
+ * Ensures every name in `onlyApps` exists as a key in `apps`.
+ */
+export function assertOnlyAppNames(
+	appKeys: string[],
+	onlyApps: string[] | undefined,
+): void {
+	if (onlyApps === undefined) return;
+	const unknown = onlyApps.filter((n) => !appKeys.includes(n));
+	if (unknown.length > 0) {
+		throw new Error(`Unknown app name(s) in onlyApps: ${unknown.join(", ")}`);
+	}
+}
+
+/**
+ * Returns a subset of `apps` when `onlyApps` is set; otherwise the full map.
+ * When `onlyApps` is `[]`, returns `{}`.
+ */
+export function pickApps<TApps extends Record<string, AppConfig>>(
+	apps: TApps,
+	onlyApps: string[] | undefined,
+): Record<string, AppConfig> {
+	if (onlyApps === undefined) return apps;
+	const out: Record<string, AppConfig> = {};
+	for (const name of onlyApps) {
+		const config = apps[name];
+		if (config !== undefined) {
+			out[name] = config;
+		}
+	}
+	return out;
+}

package/src/environment/seeding.ts

@@ -0,0 +1,57 @@
+import type {
+	AppConfig,
+	HookContext,
+	SeedCheckContext,
+	ServiceConfig,
+} from "../types";
+
+export function createCheckTableHelper<
+	TServices extends Record<string, ServiceConfig>,
+	TApps extends Record<string, AppConfig>,
+>(
+	urls: Record<string, string>,
+	exec: (
+		cmd: string,
+		options?: { throwOnError?: boolean },
+	) => Promise<{
+		exitCode: number;
+		stdout: string;
+		stderr: string;
+	}>,
+): SeedCheckContext<TServices, TApps>["checkTable"] {
+	return async (
+		tableName: string,
+		service?: keyof TServices,
+	): Promise<boolean> => {
+		const serviceName = (service ?? "postgres") as string;
+		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 shouldSeed =
+			checkResult.exitCode !== 0 || count === "0" || count === "";
+		if (!shouldSeed) {
+			console.log(`  📊 Table "${tableName}" has ${count} rows`);
+		}
+		return shouldSeed;
+	};
+}
+
+export function createSeedCheckContext<
+	TServices extends Record<string, ServiceConfig>,
+	TApps extends Record<string, AppConfig>,
+>(
+	baseContext: HookContext<TServices, TApps>,
+	checkTable: SeedCheckContext<TServices, TApps>["checkTable"],
+): SeedCheckContext<TServices, TApps> {
+	return {
+		...baseContext,
+		checkTable,
+	};
+}

package/{index.ts → src/index.ts}

@@ -3,25 +3,33 @@
 // ═══════════════════════════════════════════════════════════════════════════
 
 // CLI runner
-export { getFlagValue, hasFlag, runCli } from "./cli";
+export { getFlagValue, hasFlag, runCli } from "./cli/run-cli";
 // Config factory
 export {
 	assertValidConfig,
 	defineDevConfig,
 	mergeConfigs,
 	validateConfig,
-} from "./config";
+} from "./config/index";
+export type {
+	ClickhouseServiceOptions,
+	CustomServiceOptions,
+	PostgresServiceOptions,
+	RedisServiceOptions,
+} from "./docker-compose/services";
+// Service helpers
+export { service } from "./docker-compose/services";
 // Environment factory
-export { createDevEnvironment } from "./environment";
+export { createDevEnvironment } from "./environment/index";
+// Config loader (for programmatic access)
+export { clearDevEnvCache, getDevEnv, loadDevEnv } from "./loader/index";
 // Lint / Typecheck
 export {
 	runWorkspaceTypecheck,
 	type TypecheckResult,
 	type WorkspaceTypecheckOptions,
 	type WorkspaceTypecheckResult,
-} from "./lint";
-// Config loader (for programmatic access)
-export { clearDevEnvCache, getDevEnv, loadDevEnv } from "./loader";
+} from "./typecheck/index";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Types
@@ -34,6 +42,7 @@ export type {
 	CliOptions,
 	// Computed types
 	ComputedPorts,
+	ComputedPublicUrls,
 	ComputedUrls,
 	// Main config
 	DevConfig,
@@ -42,15 +51,26 @@ export type {
 	DevHooks,
 	DevOptions,
 	DevServerPids,
+	DockerComposeGenerationOptions,
+	DockerComposeHealthcheckRaw,
+	DockerComposeNode,
+	DockerComposeServiceRaw,
+	DockerComposeVolumeRaw,
+	DockerPresetName,
+	DockerPresetServiceDefinition,
+	DockerServiceDefinition,
 	EnvVarsBuilder,
 	ExecOptions,
 	HealthCheckFn,
 	HookContext,
 	// Migrations & Seed
 	MigrationConfig,
+	OpenPublicTunnelsOptions,
+	OpenPublicTunnelsResult,
 	// Prisma
 	PrismaConfig,
 	PrismaRunner,
+	PublicTunnelHandle,
 	SeedCheckContext,
 	SeedCheckHelpers,
 	SeedConfig,
@@ -61,33 +81,22 @@ export type {
 	StopOptions,
 	UrlBuilderContext,
 	UrlBuilderFn,
-} from "./types";
+} from "./types/index";
 
 // ═══════════════════════════════════════════════════════════════════════════
 // Core Utilities (for advanced use cases)
 // ═══════════════════════════════════════════════════════════════════════════
 
-export {
-	areContainersRunning,
-	assertDockerRunning,
-	DOCKER_NOT_RUNNING_MESSAGE,
-	isContainerRunning,
-	isDockerRunning,
-	MAX_ATTEMPTS,
-	POLL_INTERVAL,
-} from "./core/docker";
-
 export { getLocalIp, isPortAvailable, waitForServer } from "./core/network";
 export {
-	computeDevIdentity,
 	calculatePortOffset,
+	computeDevIdentity,
 	findMonorepoRoot,
 	getProjectName,
-	getWorktreeProjectSuffix,
 	getWorktreeName,
+	getWorktreeProjectSuffix,
 	isWorktree,
 } from "./core/ports";
-
 export {
 	getProcessOnPort,
 	isPortInUse,
@@ -96,6 +105,13 @@ export {
 	killProcessOnPort,
 	killProcessOnPortAndWait,
 } from "./core/process";
+export {
+	type PublicExposeTarget,
+	type PublicTunnel,
+	resolveExposeTargets,
+	startPublicTunnels,
+	stopPublicTunnels,
+} from "./core/tunnel";
 export {
 	getEnvVar,
 	isCI,
@@ -113,3 +129,19 @@ export {
 	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";

package/src/loader/cache.ts

@@ -0,0 +1,23 @@
+import type { AppConfig, DevEnvironment, ServiceConfig } from "../types";
+
+let cachedEnv: DevEnvironment<
+	Record<string, ServiceConfig>,
+	Record<string, AppConfig>
+> | null = null;
+
+export function setCachedDevEnv(
+	env: DevEnvironment<Record<string, ServiceConfig>, Record<string, AppConfig>>,
+): void {
+	cachedEnv = env;
+}
+
+export function getCachedDevEnv(): DevEnvironment<
+	Record<string, ServiceConfig>,
+	Record<string, AppConfig>
+> | null {
+	return cachedEnv;
+}
+
+export function clearDevEnvCache(): void {
+	cachedEnv = null;
+}

package/src/loader/find-config-file.ts

@@ -0,0 +1,29 @@
+import { existsSync } from "node:fs";
+import { dirname, join } from "node:path";
+
+export const CONFIG_FILES = [
+	"dev.config.ts",
+	"dev.config.js",
+	"dev-tools.config.ts",
+	"dev-tools.config.js",
+];
+
+export function findConfigFile(startDir: string): string | null {
+	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;
+	}
+}

package/src/loader/index.ts

@@ -0,0 +1,17 @@
+import type { AppConfig, DevEnvironment, ServiceConfig } from "../types";
+import { getCachedDevEnv } from "./cache";
+
+export { clearDevEnvCache } from "./cache";
+export { CONFIG_FILES, findConfigFile } from "./find-config-file";
+export { loadDevEnv } from "./load-dev-env";
+
+export function getDevEnv(): DevEnvironment<
+	Record<string, ServiceConfig>,
+	Record<string, AppConfig>
+> {
+	const env = getCachedDevEnv();
+	if (!env) {
+		throw new Error("Dev environment not loaded. Call loadDevEnv() first.");
+	}
+	return env;
+}

package/src/loader/load-dev-env.ts

@@ -0,0 +1,38 @@
+import { createDevEnvironment } from "../environment";
+import type { AppConfig, DevEnvironment, ServiceConfig } from "../types";
+import { getCachedDevEnv, setCachedDevEnv } from "./cache";
+import { findConfigFile } from "./find-config-file";
+
+export async function loadDevEnv(options?: {
+	cwd?: string;
+	reload?: boolean;
+}): Promise<
+	DevEnvironment<Record<string, ServiceConfig>, Record<string, AppConfig>>
+> {
+	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({ ... })",
+	);
+}

package/src/prisma/index.ts

@@ -0,0 +1 @@
+export * from "./prisma";

package/{prisma.ts → src/prisma/prisma.ts}

@@ -28,7 +28,7 @@ import {
 	isContainerRunning,
 	startService,
 	waitForServiceByType,
-} from "./core/docker";
+} from "../docker/runtime";
 import type {
 	AppConfig,
 	BuiltInHealthCheck,
@@ -36,7 +36,7 @@ import type {
 	PrismaConfig,
 	PrismaRunner,
 	ServiceConfig,
-} from "./types";
+} from "../types";
 
 /**
  * Create a Prisma runner from config (used internally by createDevEnvironment).
@@ -80,9 +80,11 @@ export function createPrismaRunner<
 
 		console.log(`🐳 Starting ${service}...`);
 
+		const composeFile = env.ensureComposeFile();
 		const envVars = env.buildEnvVars();
 		startService(env.root, env.projectName, service, envVars, {
 			verbose: false,
+			composeFile,
 		});
 
 		const port = (env.ports as Record<string, number>)[service];

package/src/typecheck/index.ts

@@ -0,0 +1 @@
+export * from "./typecheck";