buncargo 3.0.0 → 3.2.3

package/dist/index.js

@@ -2,19 +2,16 @@ import"./index-bj79tw5w.js";
 import {
   getFlagValue,
   hasFlag,
-  resolveExposeTargets,
-  runCli,
-  startPublicTunnels,
-  stopPublicTunnels
-} from "./index-0kxnae3z.js";
+  runCli
+} from "./index-n5g93an7.js";
 import {
   clearDevEnvCache,
   getDevEnv,
   loadDevEnv
-} from "./index-4xrxh8yv.js";
+} from "./index-bycj26kj.js";
 import {
   createDevEnvironment
-} from "./index-ma6tgdb2.js";
+} from "./index-n6z0qw70.js";
 import {
   DOCKER_NOT_RUNNING_MESSAGE,
   MAX_ATTEMPTS,
@@ -52,7 +49,11 @@ import {
   service,
   writeGeneratedComposeFile
 } from "./index-5t9jxqm0.js";
-import"./index-bnk6nr0g.js";
+import {
+  resolveExposeTargets,
+  startPublicTunnels,
+  stopPublicTunnels
+} from "./index-mf4vjhm3.js";
 import {
   getHeartbeatFile,
   getWatchdogPidFile,

package/dist/loader/index.js

@@ -4,13 +4,13 @@ import {
   findConfigFile,
   getDevEnv,
   loadDevEnv
-} from "../index-4xrxh8yv.js";
-import"../index-ma6tgdb2.js";
+} from "../index-bycj26kj.js";
+import"../index-n6z0qw70.js";
 import"../index-d8tyv5se.js";
 import"../index-c0dr6mcv.js";
 import"../index-fb29934k.js";
 import"../index-5t9jxqm0.js";
-import"../index-bnk6nr0g.js";
+import"../index-mf4vjhm3.js";
 import"../index-mam0bcyz.js";
 import"../index-mm412dkp.js";
 import"../index-t0fj6gg1.js";

package/dist/types/all-types.d.ts

@@ -382,6 +382,10 @@ export interface StartOptions {
     suffix?: string;
     /** Skip automatic seeding (useful when CLI handles seeding separately). Default: false */
     skipSeed?: boolean;
+    /** Skip the initial `logInfo` banner (CLI uses this with `--expose`, then logs once with tunnel URLs). Default: false */
+    skipEnvironmentLog?: boolean;
+    /** If set, start and wait for only these app names (must exist in `apps`). */
+    onlyApps?: string[];
 }
 /**
  * Options for stopping the dev environment.
@@ -398,6 +402,33 @@ export interface StopOptions {
 export interface DevServerPids {
     [appName: string]: number;
 }
+/** Tunnel rows passed to `logInfo` for public URL lines (matches `PublicTunnel` without `close`) */
+export interface DevEnvironmentTunnelLog {
+    kind: "service" | "app";
+    name: string;
+    localUrl: string;
+    publicUrl: string;
+}
+/** Active tunnel with teardown — same shape as core `PublicTunnel`. */
+export type PublicTunnelHandle = DevEnvironmentTunnelLog & {
+    close: () => Promise<void>;
+};
+/** Options for {@link DevEnvironment.openPublicTunnels}. */
+export interface OpenPublicTunnelsOptions {
+    /** Subset of expose targets by name; omit for all `expose: true` services/apps. */
+    names?: string[];
+    /**
+     * Wait for these apps' HTTP health endpoints before opening tunnels.
+     * Servers must already be listening on their ports.
+     */
+    waitForHealthy?: string[];
+}
+/** Result of {@link DevEnvironment.openPublicTunnels}. */
+export interface OpenPublicTunnelsResult<TServices extends Record<string, ServiceConfig>, TApps extends Record<string, AppConfig>> {
+    publicUrls: ComputedPublicUrls<TServices, TApps>;
+    tunnels: PublicTunnelHandle[];
+    close: () => Promise<void>;
+}
 /**
  * The main dev environment interface returned by createDevEnvironment().
  */
@@ -436,6 +467,8 @@ export interface DevEnvironment<TServices extends Record<string, ServiceConfig>,
     startServers(options?: {
         productionBuild?: boolean;
         verbose?: boolean;
+        /** If set, start and wait for only these app names (must exist in `apps`). */
+        onlyApps?: string[];
     }): Promise<DevServerPids>;
     /** Stop a process by PID */
     stopProcess(pid: number): void;
@@ -443,8 +476,13 @@ export interface DevEnvironment<TServices extends Record<string, ServiceConfig>,
     waitForServers(options?: {
         timeout?: number;
         productionBuild?: boolean;
+        /** If set, wait only for these app names (must exist in `apps`). */
+        onlyApps?: string[];
     }): Promise<void>;
-    /** Build environment variables for shell commands */
+    /**
+     * Build environment variables for shell commands.
+     * Call **after** {@link setPublicUrls} or {@link openPublicTunnels} so `envVars` and `*_PUBLIC_URL` reflect tunnel URLs.
+     */
     buildEnvVars(production?: boolean): Record<string, string>;
     /** Set public tunnel URLs used by envVars and *_PUBLIC_URL injection */
     setPublicUrls(urls: ComputedPublicUrls<TServices, TApps>): void;
@@ -460,8 +498,13 @@ export interface DevEnvironment<TServices extends Record<string, ServiceConfig>,
     }>;
     /** Wait for an HTTP server to respond */
     waitForServer(url: string, timeout?: number): Promise<void>;
-    /** Log environment info to console */
-    logInfo(label?: string): void;
+    /** Log environment info to console; pass `tunnels` to show public URLs next to services/apps */
+    logInfo(label?: string, tunnels?: DevEnvironmentTunnelLog[]): void;
+    /**
+     * Resolve expose targets, start public quick tunnels, and apply {@link setPublicUrls}.
+     * Call {@link buildEnvVars} after this resolves when spawning processes that need `EXPO_PUBLIC_*` / `*_PUBLIC_URL`.
+     */
+    openPublicTunnels(options?: OpenPublicTunnelsOptions): Promise<OpenPublicTunnelsResult<TServices, TApps>>;
     /**
      * Get the Expo API URL (http://<local-ip>:<api-port>) and log it for detection.
      * Used by tools like Vibe Kanban to find the API server for mobile testing.

package/package.json

@@ -1,147 +1,149 @@
 {
-	"name": "buncargo",
-	"version": "3.0.0",
-	"description": "A Bun-powered development environment CLI for managing Docker Compose services, dev servers, and environment variables",
-	"type": "module",
-	"module": "./dist/index.js",
-	"main": "./dist/index.js",
-	"types": "./dist/index.d.ts",
-	"license": "MIT",
-	"repository": {
-		"type": "git",
-		"url": "git+https://github.com/HansKristoffer/buncargo.git"
-	},
-	"author": "Kristoffer Hansen",
-	"keywords": [
-		"bun",
-		"dev-tools",
-		"docker",
-		"docker-compose",
-		"development",
-		"cli",
-		"monorepo",
-		"dev-server",
-		"environment"
-	],
-	"engines": {
-		"bun": ">=1.0.0"
-	},
-	"files": [
-		"src/**/*.ts",
-		"dist",
-		"!src/**/*.test.ts"
-	],
-	"bin": {
-		"dev-tools": "./dist/cli/bin.js",
-		"buncargo": "./dist/cli/bin.js"
-	},
-	"exports": {
-		".": {
-			"types": "./dist/index.d.ts",
-			"bun": "./src/index.ts",
-			"import": "./dist/index.js",
-			"default": "./dist/index.js"
-		},
-		"./types": {
-			"types": "./dist/types/index.d.ts",
-			"bun": "./src/types/index.ts",
-			"import": "./dist/types/index.js",
-			"default": "./dist/types/index.js"
-		},
-		"./config": {
-			"types": "./dist/config/index.d.ts",
-			"bun": "./src/config/index.ts",
-			"import": "./dist/config/index.js",
-			"default": "./dist/config/index.js"
-		},
-		"./environment": {
-			"types": "./dist/environment/index.d.ts",
-			"bun": "./src/environment/index.ts",
-			"import": "./dist/environment/index.js",
-			"default": "./dist/environment/index.js"
-		},
-		"./core/ports": {
-			"types": "./dist/core/ports.d.ts",
-			"bun": "./src/core/ports.ts",
-			"import": "./dist/core/ports.js",
-			"default": "./dist/core/ports.js"
-		},
-		"./core/network": {
-			"types": "./dist/core/network.d.ts",
-			"bun": "./src/core/network.ts",
-			"import": "./dist/core/network.js",
-			"default": "./dist/core/network.js"
-		},
-		"./core/process": {
-			"types": "./dist/core/process.d.ts",
-			"bun": "./src/core/process.ts",
-			"import": "./dist/core/process.js",
-			"default": "./dist/core/process.js"
-		},
-		"./core/watchdog": {
-			"types": "./dist/core/watchdog.d.ts",
-			"bun": "./src/core/watchdog.ts",
-			"import": "./dist/core/watchdog.js",
-			"default": "./dist/core/watchdog.js"
-		},
-		"./core/utils": {
-			"types": "./dist/core/utils.d.ts",
-			"bun": "./src/core/utils.ts",
-			"import": "./dist/core/utils.js",
-			"default": "./dist/core/utils.js"
-		},
-		"./cli": {
-			"types": "./dist/cli/index.d.ts",
-			"bun": "./src/cli/index.ts",
-			"import": "./dist/cli/index.js",
-			"default": "./dist/cli/index.js"
-		},
-		"./typecheck": {
-			"types": "./dist/typecheck/index.d.ts",
-			"bun": "./src/typecheck/index.ts",
-			"import": "./dist/typecheck/index.js",
-			"default": "./dist/typecheck/index.js"
-		},
-		"./loader": {
-			"types": "./dist/loader/index.d.ts",
-			"bun": "./src/loader/index.ts",
-			"import": "./dist/loader/index.js",
-			"default": "./dist/loader/index.js"
-		},
-		"./docker": {
-			"types": "./dist/docker/index.d.ts",
-			"bun": "./src/docker/index.ts",
-			"import": "./dist/docker/index.js",
-			"default": "./dist/docker/index.js"
-		},
-		"./docker-compose": {
-			"types": "./dist/docker-compose/index.d.ts",
-			"bun": "./src/docker-compose/index.ts",
-			"import": "./dist/docker-compose/index.js",
-			"default": "./dist/docker-compose/index.js"
-		}
-	},
-	"scripts": {
-		"build": "bun run build:js && bun run build:types",
-		"build:js": "bun build ./src/index.ts ./src/cli/bin.ts ./src/cli/index.ts ./src/config/index.ts ./src/environment/index.ts ./src/loader/index.ts ./src/typecheck/index.ts ./src/types/index.ts ./src/core/network.ts ./src/core/ports.ts ./src/core/process.ts ./src/core/utils.ts ./src/core/watchdog.ts ./src/docker/index.ts ./src/docker-compose/index.ts --outdir ./dist --root ./src --target node --packages external --splitting",
-		"build:types": "tsc -p tsconfig.build.json",
-		"prepublishOnly": "bun run build",
-		"publish:patch": "npm version patch && npm publish",
-		"publish:minor": "npm version minor && npm publish",
-		"publish:major": "npm version major && npm publish",
-		"lint": "bun run typecheck && biome check src example",
-		"lint:write": "bun run typecheck && biome check --fix src example && biome format src example",
-		"typecheck": "tsgo --incremental"
-	},
-	"devDependencies": {
-		"@types/bun": "1.3.2",
-		"@biomejs/biome": "2.3.4",
-		"@typescript/native-preview": "7.0.0-dev.20260127.1",
-		"typescript": "^5.7.0"
-	},
-	"dependencies": {
-		"fast-glob": "^3.3.3",
-		"picocolors": "^1.1.1",
-		"untun": "^0.1.3"
-	}
+  "name": "buncargo",
+  "version": "3.2.3",
+  "description": "A Bun-powered development environment CLI for managing Docker Compose services, dev servers, and environment variables",
+  "type": "module",
+  "module": "./dist/index.js",
+  "main": "./dist/index.js",
+  "types": "./dist/index.d.ts",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "git+https://github.com/HansKristoffer/buncargo.git"
+  },
+  "author": "Kristoffer Hansen",
+  "keywords": [
+    "bun",
+    "dev-tools",
+    "docker",
+    "docker-compose",
+    "development",
+    "cli",
+    "monorepo",
+    "dev-server",
+    "environment"
+  ],
+  "engines": {
+    "bun": ">=1.0.0"
+  },
+  "files": [
+    "src/**/*.ts",
+    "dist",
+    "!src/**/*.test.ts"
+  ],
+  "bin": {
+    "dev-tools": "./dist/cli/bin.js",
+    "buncargo": "./dist/cli/bin.js"
+  },
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js",
+      "default": "./dist/index.js"
+    },
+    "./types": {
+      "types": "./dist/types/index.d.ts",
+      "bun": "./src/types/index.ts",
+      "import": "./dist/types/index.js",
+      "default": "./dist/types/index.js"
+    },
+    "./config": {
+      "types": "./dist/config/index.d.ts",
+      "bun": "./src/config/index.ts",
+      "import": "./dist/config/index.js",
+      "default": "./dist/config/index.js"
+    },
+    "./environment": {
+      "types": "./dist/environment/index.d.ts",
+      "bun": "./src/environment/index.ts",
+      "import": "./dist/environment/index.js",
+      "default": "./dist/environment/index.js"
+    },
+    "./core/ports": {
+      "types": "./dist/core/ports.d.ts",
+      "bun": "./src/core/ports.ts",
+      "import": "./dist/core/ports.js",
+      "default": "./dist/core/ports.js"
+    },
+    "./core/network": {
+      "types": "./dist/core/network.d.ts",
+      "bun": "./src/core/network.ts",
+      "import": "./dist/core/network.js",
+      "default": "./dist/core/network.js"
+    },
+    "./core/process": {
+      "types": "./dist/core/process.d.ts",
+      "bun": "./src/core/process.ts",
+      "import": "./dist/core/process.js",
+      "default": "./dist/core/process.js"
+    },
+    "./core/watchdog": {
+      "types": "./dist/core/watchdog.d.ts",
+      "bun": "./src/core/watchdog.ts",
+      "import": "./dist/core/watchdog.js",
+      "default": "./dist/core/watchdog.js"
+    },
+    "./core/utils": {
+      "types": "./dist/core/utils.d.ts",
+      "bun": "./src/core/utils.ts",
+      "import": "./dist/core/utils.js",
+      "default": "./dist/core/utils.js"
+    },
+    "./cli": {
+      "types": "./dist/cli/index.d.ts",
+      "bun": "./src/cli/index.ts",
+      "import": "./dist/cli/index.js",
+      "default": "./dist/cli/index.js"
+    },
+    "./typecheck": {
+      "types": "./dist/typecheck/index.d.ts",
+      "bun": "./src/typecheck/index.ts",
+      "import": "./dist/typecheck/index.js",
+      "default": "./dist/typecheck/index.js"
+    },
+    "./loader": {
+      "types": "./dist/loader/index.d.ts",
+      "bun": "./src/loader/index.ts",
+      "import": "./dist/loader/index.js",
+      "default": "./dist/loader/index.js"
+    },
+    "./docker": {
+      "types": "./dist/docker/index.d.ts",
+      "bun": "./src/docker/index.ts",
+      "import": "./dist/docker/index.js",
+      "default": "./dist/docker/index.js"
+    },
+    "./docker-compose": {
+      "types": "./dist/docker-compose/index.d.ts",
+      "bun": "./src/docker-compose/index.ts",
+      "import": "./dist/docker-compose/index.js",
+      "default": "./dist/docker-compose/index.js"
+    }
+  },
+  "scripts": {
+    "build": "bun run build:js && bun run build:types",
+    "build:js": "bun build ./src/index.ts ./src/cli/bin.ts ./src/cli/index.ts ./src/config/index.ts ./src/environment/index.ts ./src/loader/index.ts ./src/typecheck/index.ts ./src/types/index.ts ./src/core/network.ts ./src/core/ports.ts ./src/core/process.ts ./src/core/utils.ts ./src/core/watchdog.ts ./src/docker/index.ts ./src/docker-compose/index.ts --outdir ./dist --root ./src --target node --packages external --splitting",
+    "build:types": "tsc -p tsconfig.build.json",
+    "prepublishOnly": "bun run build",
+    "publish:patch": "npm version patch && npm publish",
+    "publish:minor": "npm version minor && npm publish",
+    "publish:major": "npm version major && npm publish",
+    "lint": "bun run typecheck && biome check src example",
+    "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"
+  },
+  "devDependencies": {
+    "@types/bun": "1.3.2",
+    "@biomejs/biome": "2.3.4",
+    "@typescript/native-preview": "7.0.0-dev.20260127.1",
+    "typescript": "^5.7.0"
+  },
+  "dependencies": {
+    "fast-glob": "^3.3.3",
+    "picocolors": "^1.1.1"
+  }
 }

package/readme.md

@@ -179,6 +179,8 @@ apps: {
 }
 ```
 
+Use `onlyApps` on `start()` or `startServers()` to launch and wait for only those named apps (same env injection and health checks as when all apps run).
+
 ## Environment Variables
 
 The `envVars` function builds all env vars from computed ports and URLs:
@@ -193,6 +195,14 @@ envVars: (ports, urls, { localIp, publicUrls }) => ({
 })
 ```
 
+`buildEnvVars()` always includes, for each service/app name `foo`:
+
+- `FOO_PORT` — assigned port
+- `FOO_URL` — local URL (LAN)
+- `FOO_PUBLIC_URL` — only while a public tunnel is active for that name
+
+Your `envVars` callback receives `publicUrls` and typically maps client bundles, e.g. `EXPO_PUBLIC_API_URL: publicUrls.api ?? urls.api`.
+
 These are injected into:
 - Docker Compose services
 - Dev server processes
@@ -246,6 +256,12 @@ envVars: (_ports, urls, { publicUrls }) => ({
 })
 ```
 
+**CLI vs programmatic ordering:** `bunx buncargo dev --expose` starts Cloudflare quick tunnels after containers and migrations but **before** the interactive dev-server command (e.g. `concurrently`) runs. Until those servers are listening on their ports, tunnel traffic can briefly error. For “servers first, then public URLs,” use the API: e.g. `await dev.startServers({ onlyApps: ['api', 'platform'] })`, then `await dev.openPublicTunnels({ waitForHealthy: ['api', 'platform'] })` (optional; waits HTTP health first), then read `dev.buildEnvVars()` for spawned children.
+
+**Expo hybrid:** buncargo is suited to exposing **API** and **platform** (Vite, etc.) for devices on cellular. **Metro** often uses Expo’s own tunnel (`expo start --tunnel`); you usually do **not** add Metro as a buncargo `app` unless you want buncargo to start it. Wire `EXPO_PUBLIC_*` from `publicUrls.* ?? urls.*` in `envVars`.
+
+**Programmatic helper:** `openPublicTunnels({ names?, waitForHealthy? })` applies tunnel URLs via `setPublicUrls` and returns `close()` to stop tunnels and clear public URLs. Call `buildEnvVars()` after `openPublicTunnels` resolves so `envVars` and `*_PUBLIC_URL` see the tunnel origins.
+
 ## Lifecycle Hooks
 
 Run code at specific points in the startup/shutdown cycle:

package/src/cli/run-cli.ts

@@ -7,7 +7,6 @@ import {
 	stopPublicTunnels,
 } from "../core/tunnel";
 import { spawnWatchdog, startHeartbeat, stopHeartbeat } from "../core/watchdog";
-import { logPublicUrls } from "../environment/logging";
 import type {
 	AppConfig,
 	CliOptions,
@@ -88,14 +87,27 @@ export async function runCli<
 	TApps extends Record<string, AppConfig>,
 >(
 	env: DevEnvironment<TServices, TApps>,
-	options: CliOptions = {},
+	options: CliOptions & {
+		/** Substitute tunnel helpers (used by CLI integration tests). */
+		cliTestTunnel?: {
+			resolveExposeTargets: typeof resolveExposeTargets;
+			startPublicTunnels: typeof startPublicTunnels;
+			stopPublicTunnels: typeof stopPublicTunnels;
+		};
+	} = {},
 ): Promise<void> {
 	const {
 		args = process.argv.slice(2),
 		watchdog = true,
 		watchdogTimeout = 10,
 		devServersCommand,
+		cliTestTunnel,
 	} = options;
+	const tunnelApi = cliTestTunnel ?? {
+		resolveExposeTargets,
+		startPublicTunnels,
+		stopPublicTunnels,
+	};
 	const exposeRequested = hasFlag(args, "--expose");
 	const exposeValue = getFlagValue(args, "--expose");
 	let tunnels: PublicTunnel[] = [];
@@ -103,7 +115,7 @@ export async function runCli<
 	async function cleanupTunnels(): Promise<void> {
 		env.clearPublicUrls();
 		if (tunnels.length === 0) return;
-		await stopPublicTunnels(tunnels);
+		await tunnelApi.stopPublicTunnels(tunnels);
 		tunnels = [];
 	}
 
@@ -143,13 +155,16 @@ export async function runCli<
 	// All other paths need containers + migrations
 	// Skip automatic seeding when --seed flag is used (CLI handles it explicitly)
 	const skipSeed = args.includes("--seed");
-	await env.start({ startServers: false, wait: true, skipSeed });
+	await env.start({
+		startServers: false,
+		wait: true,
+		skipSeed,
+		skipEnvironmentLog: exposeRequested,
+	});
 
 	if (exposeRequested) {
-		const { targets, unknownNames, notEnabledNames } = resolveExposeTargets(
-			env,
-			exposeValue,
-		);
+		const { targets, unknownNames, notEnabledNames } =
+			tunnelApi.resolveExposeTargets(env, exposeValue);
 		if (unknownNames.length > 0) {
 			console.error(
 				`❌ Unknown expose target${unknownNames.length > 1 ? "s" : ""}: ${unknownNames.join(", ")}`,
@@ -175,13 +190,13 @@ export async function runCli<
 			process.exit(1);
 		}
 
-		tunnels = await startPublicTunnels(targets);
+		tunnels = await tunnelApi.startPublicTunnels(targets);
 		env.setPublicUrls(
 			Object.fromEntries(
 				tunnels.map((tunnel) => [tunnel.name, tunnel.publicUrl]),
 			) as typeof env.publicUrls,
 		);
-		logPublicUrls(tunnels);
+		env.logInfo("Dev Environment", tunnels);
 	}
 
 	// Handle --migrate (exit after migrations)
@@ -351,10 +366,10 @@ function runCommand(
 // ═══════════════════════════════════════════════════════════════════════════
 
 /**
- * Check if a CLI flag is present.
+ * Check if a CLI flag is present (including `--flag=value` form).
  */
 export function hasFlag(args: string[], flag: string): boolean {
-	return args.includes(flag);
+	return args.some((arg) => arg === flag || arg.startsWith(`${flag}=`));
 }
 
 /**

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

@@ -0,0 +1,83 @@
+/**
+ * Spawn cloudflared and parse the quick-tunnel public URL from output.
+ * Derived from unjs/untun (MIT), originally forked from node-cloudflared.
+ */
+import { type ChildProcess, spawn } from "node:child_process";
+import { cloudflaredBinPath } from "./constants";
+
+const urlRegex = /\|\s+(https?:\/\/\S+)/;
+
+export function startCloudflaredTunnel(
+	options: Record<string, string | number | null>,
+): {
+	url: Promise<string>;
+	child: ChildProcess;
+	stop: () => boolean;
+} {
+	const args: string[] = ["tunnel"];
+	for (const [key, value] of Object.entries(options)) {
+		if (typeof value === "string") {
+			args.push(`${key}`, value);
+		} else if (typeof value === "number") {
+			args.push(`${key}`, value.toString());
+		} else if (value === null) {
+			args.push(`${key}`);
+		}
+	}
+	if (args.length === 1) {
+		args.push("--url", "localhost:8080");
+	}
+
+	const child = spawn(cloudflaredBinPath, args, {
+		stdio: ["ignore", "pipe", "pipe"],
+	});
+
+	if (process.env.DEBUG) {
+		child.stdout?.pipe(process.stdout);
+		child.stderr?.pipe(process.stderr);
+	}
+
+	let settled = false;
+	let urlResolver!: (value: string | PromiseLike<string>) => void;
+	let urlRejector!: (reason: unknown) => void;
+	const url = new Promise<string>((resolve, reject) => {
+		urlResolver = (v) => {
+			if (!settled) {
+				settled = true;
+				resolve(v);
+			}
+		};
+		urlRejector = (e) => {
+			if (!settled) {
+				settled = true;
+				reject(e);
+			}
+		};
+	});
+
+	const parser = (data: Buffer) => {
+		const str = data.toString();
+
+		const urlMatch = str.match(urlRegex);
+		if (urlMatch) {
+			urlResolver(urlMatch[1] ?? "");
+		}
+	};
+	child.stdout?.on("data", parser).on("error", urlRejector);
+	child.stderr?.on("data", parser).on("error", urlRejector);
+
+	child.on("exit", (code, signal) => {
+		if (!settled) {
+			urlRejector(
+				new Error(
+					`cloudflared exited before a tunnel URL was parsed (code=${code}, signal=${signal ?? "none"})`,
+				),
+			);
+		}
+	});
+	child.on("error", urlRejector);
+
+	const stop = () => child.kill("SIGINT");
+
+	return { url, child, stop };
+}