buncargo 3.2.3 → 3.2.5

package/dist/index-znaek8z2.js

@@ -0,0 +1,72 @@
+import {
+  createDevEnvironment
+} from "./index-ymdvr5sn.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.js

@@ -3,15 +3,15 @@ import {
   getFlagValue,
   hasFlag,
   runCli
-} from "./index-n5g93an7.js";
+} from "./index-c28x1pjb.js";
 import {
   clearDevEnvCache,
   getDevEnv,
   loadDevEnv
-} from "./index-bycj26kj.js";
+} from "./index-znaek8z2.js";
 import {
   createDevEnvironment
-} from "./index-n6z0qw70.js";
+} from "./index-ymdvr5sn.js";
 import {
   DOCKER_NOT_RUNNING_MESSAGE,
   MAX_ATTEMPTS,
@@ -20,27 +20,7 @@ import {
   assertDockerRunning,
   isContainerRunning,
   isDockerRunning
-} from "./index-d8tyv5se.js";
-import {
-  getEnvVar,
-  getLocalIp,
-  isCI,
-  isPortAvailable,
-  logApiUrl,
-  logExpoApiUrl,
-  logFrontendPort,
-  sleep,
-  waitForServer
-} from "./index-c0dr6mcv.js";
-import {
-  calculatePortOffset,
-  computeDevIdentity,
-  findMonorepoRoot,
-  getProjectName,
-  getWorktreeName,
-  getWorktreeProjectSuffix,
-  isWorktree
-} from "./index-fb29934k.js";
+} from "./index-twwcjn9p.js";
 import {
   DEFAULT_GENERATED_COMPOSE_FILE,
   buildComposeModel,
@@ -53,7 +33,7 @@ import {
   resolveExposeTargets,
   startPublicTunnels,
   stopPublicTunnels
-} from "./index-mf4vjhm3.js";
+} from "./index-bgcx898h.js";
 import {
   getHeartbeatFile,
   getWatchdogPidFile,
@@ -71,6 +51,26 @@ import {
   killProcessOnPortAndWait,
   killProcessesOnAppPorts
 } from "./index-mm412dkp.js";
+import {
+  getEnvVar,
+  getLocalIp,
+  isCI,
+  isPortAvailable,
+  logApiUrl,
+  logExpoApiUrl,
+  logFrontendPort,
+  sleep,
+  waitForServer
+} from "./index-fkgqg6w2.js";
+import {
+  calculatePortOffset,
+  computeDevIdentity,
+  findMonorepoRoot,
+  getProjectName,
+  getWorktreeName,
+  getWorktreeProjectSuffix,
+  isWorktree
+} from "./index-fb29934k.js";
 import {
   assertValidConfig,
   defineDevConfig,

package/dist/loader/index.js

@@ -4,15 +4,15 @@ import {
   findConfigFile,
   getDevEnv,
   loadDevEnv
-} from "../index-bycj26kj.js";
-import"../index-n6z0qw70.js";
-import"../index-d8tyv5se.js";
-import"../index-c0dr6mcv.js";
-import"../index-fb29934k.js";
+} from "../index-znaek8z2.js";
+import"../index-ymdvr5sn.js";
+import"../index-twwcjn9p.js";
 import"../index-5t9jxqm0.js";
-import"../index-mf4vjhm3.js";
+import"../index-bgcx898h.js";
 import"../index-mam0bcyz.js";
 import"../index-mm412dkp.js";
+import"../index-fkgqg6w2.js";
+import"../index-fb29934k.js";
 import"../index-t0fj6gg1.js";
 import"../index-qnx9j3qa.js";
 export {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "buncargo",
-  "version": "3.2.3",
+  "version": "3.2.5",
   "description": "A Bun-powered development environment CLI for managing Docker Compose services, dev servers, and environment variables",
   "type": "module",
   "module": "./dist/index.js",
@@ -133,8 +133,8 @@
     "lint:write": "bun run typecheck && biome check --fix src example && biome format src example",
     "typecheck": "tsgo --incremental",
     "test": "bun test",
-    "test:integration-cloudflared": "bun test src/core/quick-tunnel/quick-tunnel.test.ts",
-    "test:integration-cloudflared-e2e": "BUNCARGO_TEST_CLOUDFLARED_E2E=1 bun test src/core/quick-tunnel/quick-tunnel.test.ts"
+    "test:integration-cloudflared": "BUNCARGO_TEST_CLOUDFLARED_SMOKE=1 bun test src/core/quick-tunnel/quick-tunnel.test.ts",
+    "test:integration-cloudflared-e2e": "BUNCARGO_TEST_CLOUDFLARED_SMOKE=1 BUNCARGO_TEST_CLOUDFLARED_E2E=1 bun test src/core/quick-tunnel/quick-tunnel.test.ts"
   },
   "devDependencies": {
     "@types/bun": "1.3.2",

package/src/core/quick-tunnel/cloudflared-process.ts

@@ -3,9 +3,34 @@
  * Derived from unjs/untun (MIT), originally forked from node-cloudflared.
  */
 import { type ChildProcess, spawn } from "node:child_process";
-import { cloudflaredBinPath } from "./constants";
+import { resolvedCloudflaredBinPath } from "./constants";
 
-const urlRegex = /\|\s+(https?:\/\/\S+)/;
+/** Primary: ASCII box line from cloudflared (`|  https://…  |`). */
+const urlRegexPipe = /\|\s+(https?:\/\/\S+)/;
+/** Fallback: URL may appear without the leading pipe if logs wrap or format changes. */
+const urlRegexTryCloudflare =
+	/(https:\/\/[a-zA-Z0-9][-a-zA-Z0-9.]*\.trycloudflare\.com)\b/;
+
+const MAX_CAPTURED_LOG = 24_000;
+
+/** Default 30s; set `BUNCARGO_QUICK_TUNNEL_TIMEOUT_MS=0` to disable. */
+export function resolveQuickTunnelUrlTimeoutMs(): number {
+	const raw = process.env.BUNCARGO_QUICK_TUNNEL_TIMEOUT_MS;
+	if (raw === undefined || raw === "") {
+		return 30_000;
+	}
+	const n = Number.parseInt(raw, 10);
+	return Number.isFinite(n) && n >= 0 ? n : 30_000;
+}
+
+export function parseQuickTunnelUrlFromOutput(log: string): string | null {
+	const pipe = log.match(urlRegexPipe);
+	if (pipe?.[1]) {
+		return pipe[1];
+	}
+	const direct = log.match(urlRegexTryCloudflare);
+	return direct?.[1] ?? null;
+}
 
 export function startCloudflaredTunnel(
 	options: Record<string, string | number | null>,
@@ -28,7 +53,8 @@ export function startCloudflaredTunnel(
 		args.push("--url", "localhost:8080");
 	}
 
-	const child = spawn(cloudflaredBinPath, args, {
+	const binPath = resolvedCloudflaredBinPath();
+	const child = spawn(binPath, args, {
 		stdio: ["ignore", "pipe", "pipe"],
 	});
 
@@ -40,37 +66,72 @@ export function startCloudflaredTunnel(
 	let settled = false;
 	let urlResolver!: (value: string | PromiseLike<string>) => void;
 	let urlRejector!: (reason: unknown) => void;
+	let timeoutId: ReturnType<typeof setTimeout> | undefined;
+
+	const clearUrlTimeout = () => {
+		if (timeoutId !== undefined) {
+			clearTimeout(timeoutId);
+			timeoutId = undefined;
+		}
+	};
+
 	const url = new Promise<string>((resolve, reject) => {
 		urlResolver = (v) => {
 			if (!settled) {
 				settled = true;
+				clearUrlTimeout();
 				resolve(v);
 			}
 		};
 		urlRejector = (e) => {
 			if (!settled) {
 				settled = true;
+				clearUrlTimeout();
 				reject(e);
 			}
 		};
-	});
 
-	const parser = (data: Buffer) => {
-		const str = data.toString();
+		const timeoutMs = resolveQuickTunnelUrlTimeoutMs();
+		if (timeoutMs > 0) {
+			timeoutId = setTimeout(() => {
+				try {
+					child.kill("SIGINT");
+				} catch {
+					/* ignore */
+				}
+				urlRejector(
+					new Error(
+						`quick tunnel URL timed out after ${timeoutMs}ms (no public URL from cloudflared)`,
+					),
+				);
+			}, timeoutMs);
+		}
+	});
 
-		const urlMatch = str.match(urlRegex);
-		if (urlMatch) {
-			urlResolver(urlMatch[1] ?? "");
+	const log: { buf: string } = { buf: "" };
+	const append = (data: Buffer) => {
+		log.buf += data.toString();
+		if (log.buf.length > MAX_CAPTURED_LOG) {
+			log.buf = log.buf.slice(-MAX_CAPTURED_LOG);
+		}
+		const url = parseQuickTunnelUrlFromOutput(log.buf);
+		if (url) {
+			urlResolver(url);
 		}
 	};
-	child.stdout?.on("data", parser).on("error", urlRejector);
-	child.stderr?.on("data", parser).on("error", urlRejector);
+	child.stdout?.on("data", append).on("error", urlRejector);
+	child.stderr?.on("data", append).on("error", urlRejector);
 
 	child.on("exit", (code, signal) => {
 		if (!settled) {
+			const tail = log.buf.trimEnd();
+			const excerpt = tail.length > 1200 ? `…${tail.slice(-1200)}` : tail;
+			const detail = excerpt ? `\ncloudflared output (tail):\n${excerpt}` : "";
 			urlRejector(
 				new Error(
-					`cloudflared exited before a tunnel URL was parsed (code=${code}, signal=${signal ?? "none"})`,
+					`cloudflared exited before a tunnel URL was parsed (code=${code}, signal=${signal ?? "none"}). ` +
+						`Parallel quick-tunnel requests are often rate-limited; buncargo starts tunnels sequentially with a short pause. ` +
+						`If this persists, try fewer expose targets or increase BUNCARGO_EXPOSE_TUNNEL_STAGGER_MS.${detail}`,
 				),
 			);
 		}

package/src/core/quick-tunnel/constants.ts

@@ -3,11 +3,12 @@
  * Derived from unjs/untun (MIT), originally forked from node-cloudflared.
  */
 
+import { existsSync } from "node:fs";
 import { tmpdir } from "node:os";
 import path from "node:path";
 
 export const CLOUDFLARED_VERSION =
-	process.env.CLOUDFLARED_VERSION || "2023.10.0";
+	process.env.CLOUDFLARED_VERSION || "2026.3.0";
 
 export const RELEASE_BASE =
 	"https://github.com/cloudflare/cloudflared/releases/";
@@ -21,6 +22,18 @@ export const cloudflaredBinPath = path.join(
 		: `cloudflared.${CLOUDFLARED_VERSION}`,
 );
 
+/** Spawn/install target: optional `BUNCARGO_CLOUDFLARED_PATH` overrides the bundled cache path. */
+export function resolvedCloudflaredBinPath(): string {
+	const override = process.env.BUNCARGO_CLOUDFLARED_PATH?.trim();
+	if (override) {
+		if (!existsSync(override)) {
+			throw new Error(`BUNCARGO_CLOUDFLARED_PATH does not exist: ${override}`);
+		}
+		return path.resolve(override);
+	}
+	return cloudflaredBinPath;
+}
+
 export const cloudflaredNotice = `
 🔥 Your installation of cloudflared software constitutes a symbol of your signature
  indicating that you accept the terms of the Cloudflare License, Terms and Privacy Policy.

package/src/core/quick-tunnel/index.ts

@@ -3,18 +3,90 @@
  * License / download flow adapted from unjs/untun (MIT).
  */
 import { existsSync } from "node:fs";
-import { createInterface } from "node:readline";
+import { sleep } from "../utils";
 import { startCloudflaredTunnel } from "./cloudflared-process";
-import { cloudflaredBinPath, cloudflaredNotice } from "./constants";
+import {
+	cloudflaredBinPath,
+	cloudflaredNotice,
+	resolvedCloudflaredBinPath,
+} from "./constants";
 import { installCloudflared } from "./install";
 
+function resolveMaxQuickTunnelAttempts(): number {
+	const raw = process.env.BUNCARGO_QUICK_TUNNEL_MAX_ATTEMPTS;
+	if (raw === undefined || raw === "") {
+		return 5;
+	}
+	const n = Number.parseInt(raw, 10);
+	return Number.isFinite(n) && n >= 1 ? n : 5;
+}
+
+function resolveQuickTunnelRetryBaseMs(): number {
+	const raw = process.env.BUNCARGO_QUICK_TUNNEL_RETRY_BASE_MS;
+	if (raw === undefined || raw === "") {
+		return 2000;
+	}
+	const n = Number.parseInt(raw, 10);
+	return Number.isFinite(n) && n >= 0 ? n : 2000;
+}
+
+function usesBundledCloudflaredCache(): boolean {
+	return !process.env.BUNCARGO_CLOUDFLARED_PATH?.trim();
+}
+
+/** True when trycloudflare.com is overloaded / rate-limited or returns non-JSON (cloudflared then errors on unmarshal). */
+export function isRetryableQuickTunnelError(message: string): boolean {
+	return (
+		message.includes("429") ||
+		message.includes("Too Many Requests") ||
+		message.includes('status_code="429') ||
+		// Plain-text "error" or HTML error pages — see cloudflare/cloudflared#972
+		message.includes("failed to unmarshal quick Tunnel") ||
+		message.includes("failed to unmarshall quick Tunnel") ||
+		message.includes("Error unmarshaling QuickTunnel") ||
+		message.includes("invalid character '<'") ||
+		message.includes("quick tunnel URL timed out")
+	);
+}
+
+async function startCloudflaredTunnelWithRetry(
+	cfArgs: Record<string, string | number | null>,
+): Promise<ReturnType<typeof startCloudflaredTunnel>> {
+	const maxAttempts = resolveMaxQuickTunnelAttempts();
+	const baseMs = resolveQuickTunnelRetryBaseMs();
+
+	for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+		const tunnel = startCloudflaredTunnel(cfArgs);
+		try {
+			await tunnel.url;
+			return tunnel;
+		} catch (e) {
+			try {
+				tunnel.stop();
+			} catch {
+				/* ignore */
+			}
+			const msg = String(e);
+			if (attempt < maxAttempts && isRetryableQuickTunnelError(msg)) {
+				const delayMs = baseMs * attempt;
+				console.log(
+					`Cloudflare quick tunnel temporarily unavailable (${attempt}/${maxAttempts}), retrying in ${delayMs}ms…`,
+				);
+				await sleep(delayMs);
+				continue;
+			}
+			throw e;
+		}
+	}
+	throw new Error("startCloudflaredTunnelWithRetry: exhausted attempts");
+}
+
 export interface QuickTunnelOptions {
 	url?: string;
 	port?: number | string;
 	hostname?: string;
 	protocol?: "http" | "https";
 	verifyTLS?: boolean;
-	acceptCloudflareNotice?: boolean;
 }
 
 export interface QuickTunnel {
@@ -29,52 +101,22 @@ function resolvedLocalUrl(opts: QuickTunnelOptions): string {
 	);
 }
 
-function envAcceptsCloudflareNotice(): boolean {
-	const v = process.env.BUNCARGO_ACCEPT_CLOUDFLARE_NOTICE;
-	const u = process.env.UNTUN_ACCEPT_CLOUDFLARE_NOTICE;
-	return v === "1" || v === "true" || u === "1" || u === "true";
-}
-
-async function promptInstallCloudflared(): Promise<boolean> {
-	if (!process.stdin.isTTY || !process.stdout.isTTY) {
-		return false;
-	}
-	return new Promise((resolve) => {
-		const rl = createInterface({
-			input: process.stdin,
-			output: process.stdout,
-		});
-		rl.question(
-			"Do you agree with the above terms and wish to install the binary from GitHub? (y/N) ",
-			(answer) => {
-				rl.close();
-				resolve(/^y(es)?$/i.test(answer.trim()));
-			},
-		);
-	});
-}
-
 /**
  * Start a Cloudflare quick tunnel to a local HTTP(S) URL.
- * Returns undefined if the user declines the cloudflared install (when binary is missing).
+ * If the cloudflared binary is missing, prints the license notice and installs it from GitHub.
  */
 export async function startQuickTunnel(
 	opts: QuickTunnelOptions,
-): Promise<QuickTunnel | undefined> {
+): Promise<QuickTunnel> {
 	const url = resolvedLocalUrl(opts);
 
 	console.log(`Starting cloudflared tunnel to ${url}`);
 
-	if (!existsSync(cloudflaredBinPath)) {
+	// Resolve path first (throws if BUNCARGO_CLOUDFLARED_PATH is invalid).
+	resolvedCloudflaredBinPath();
+
+	if (usesBundledCloudflaredCache() && !existsSync(cloudflaredBinPath)) {
 		console.log(cloudflaredNotice);
-		const canInstall =
-			opts.acceptCloudflareNotice ||
-			envAcceptsCloudflareNotice() ||
-			(await promptInstallCloudflared());
-		if (!canInstall) {
-			console.error("Skipping tunnel setup.");
-			return;
-		}
 		await installCloudflared();
 	}
 
@@ -83,7 +125,7 @@ export async function startQuickTunnel(
 	if (!opts.verifyTLS) {
 		cfArgs["--no-tls-verify"] = null;
 	}
-	const tunnel = startCloudflaredTunnel(cfArgs);
+	const tunnel = await startCloudflaredTunnelWithRetry(cfArgs);
 
 	const cleanup = async () => {
 		tunnel.stop();

package/src/core/quick-tunnel/install.ts

@@ -20,7 +20,7 @@ const LINUX_URL: Partial<Record<NodeJS.Architecture, string>> = {
 };
 
 const MACOS_URL: Partial<Record<NodeJS.Architecture, string>> = {
-	arm64: "cloudflared-darwin-amd64.tgz",
+	arm64: "cloudflared-darwin-arm64.tgz",
 	x64: "cloudflared-darwin-amd64.tgz",
 };
 

package/src/core/tunnel.ts

@@ -1,5 +1,6 @@
 import type { AppConfig, DevEnvironment, ServiceConfig } from "../types";
 import { startQuickTunnel } from "./quick-tunnel";
+import { sleep } from "./utils";
 
 export interface PublicExposeTarget {
 	kind: "service" | "app";
@@ -115,6 +116,15 @@ export function resolveExposeTargets<
 	return { targets, unknownNames, notEnabledNames };
 }
 
+function resolveExposeTunnelStaggerMs(): number {
+	const raw = process.env.BUNCARGO_EXPOSE_TUNNEL_STAGGER_MS;
+	if (raw === undefined || raw === "") {
+		return 900;
+	}
+	const n = Number.parseInt(raw, 10);
+	return Number.isFinite(n) && n >= 0 ? n : 900;
+}
+
 export async function startPublicTunnels(
 	targets: PublicExposeTarget[],
 	options: {
@@ -124,16 +134,23 @@ export async function startPublicTunnels(
 	} = {},
 ): Promise<PublicTunnel[]> {
 	const start = options.start ?? ((input) => startQuickTunnel(input));
+	const staggerMs = resolveExposeTunnelStaggerMs();
 
-	const settled = await Promise.allSettled(
-		targets.map(async (target) => {
+	const tunnels: PublicTunnel[] = [];
+	try {
+		let index = 0;
+		for (const target of targets) {
+			if (index > 0 && staggerMs > 0) {
+				await sleep(staggerMs);
+			}
+			index += 1;
 			const localUrl = `http://localhost:${target.port}`;
 			const tunnel = (await start({
 				url: localUrl,
 			})) as TunnelBackendResult | undefined;
 			if (tunnel === undefined) {
 				throw new Error(
-					`Tunnel for "${target.name}" could not be started (cloudflared missing or install declined)`,
+					`Tunnel for "${target.name}" could not be started (tunnel backend returned no instance)`,
 				);
 			}
 			const publicUrl = await resolvePublicUrl(tunnel);
@@ -142,32 +159,19 @@ export async function startPublicTunnels(
 					`Tunnel for "${target.name}" did not provide a public URL`,
 				);
 			}
-			return {
+			tunnels.push({
 				kind: target.kind,
 				name: target.name,
 				localUrl,
 				publicUrl,
 				close: toCloseFn(tunnel),
-			};
-		}),
-	);
-
-	const tunnels: PublicTunnel[] = [];
-	const errors: unknown[] = [];
-	for (const result of settled) {
-		if (result.status === "fulfilled") {
-			tunnels.push(result.value);
-		} else {
-			errors.push(result.reason);
+			});
 		}
-	}
-
-	if (errors.length > 0) {
+		return tunnels;
+	} catch (e) {
 		await stopPublicTunnels(tunnels);
-		throw errors[0];
+		throw e;
 	}
-
-	return tunnels;
 }
 
 export async function stopPublicTunnels(