bantou 0.1.0 → 0.2.0

package/.output/server/node_modules/untun/dist/_chunks/cloudflared.mjs

@@ -0,0 +1,179 @@
+import fs from "node:fs";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import https from "node:https";
+import { execSync, spawn } from "node:child_process";
+import { once } from "node:events";
+const CLOUDFLARED_VERSION = process.env.CLOUDFLARED_VERSION || "2026.7.2";
+const RELEASE_BASE = "https://github.com/cloudflare/cloudflared/releases/";
+const cloudflaredBinPath = path.join(tmpdir(), "node-untun", process.platform === "win32" ? `cloudflared.${CLOUDFLARED_VERSION}.exe` : `cloudflared.${CLOUDFLARED_VERSION}`);
+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.
+
+❯ License:         https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/license/
+❯ Terms:           https://www.cloudflare.com/terms/
+❯ Privacy Policy:  https://www.cloudflare.com/privacypolicy/
+`;
+const connRegex = /connection[ =]([\da-z-]+)/i;
+const ipRegex = /ip=([\d.]+)/;
+const locationRegex = /location=([A-Z]+)/;
+const indexRegex = /connIndex=(\d)/;
+const LINUX_URL = {
+	arm64: "cloudflared-linux-arm64",
+	arm: "cloudflared-linux-arm",
+	x64: "cloudflared-linux-amd64",
+	ia32: "cloudflared-linux-386"
+};
+const MACOS_URL = {
+	arm64: "cloudflared-darwin-amd64.tgz",
+	x64: "cloudflared-darwin-amd64.tgz"
+};
+const WINDOWS_URL = {
+	x64: "cloudflared-windows-amd64.exe",
+	ia32: "cloudflared-windows-386.exe"
+};
+function resolveBase(version) {
+	if (version === "latest") return `${RELEASE_BASE}latest/download/`;
+	return `${RELEASE_BASE}download/${version}/`;
+}
+function installCloudflared(to = cloudflaredBinPath, version = CLOUDFLARED_VERSION) {
+	switch (process.platform) {
+		case "linux": return installLinux(to, version);
+		case "darwin": return installMacos(to, version);
+		case "win32": return installWindows(to, version);
+		default: throw new Error("Unsupported platform: " + process.platform);
+	}
+}
+async function installLinux(to, version = CLOUDFLARED_VERSION) {
+	const file = LINUX_URL[process.arch];
+	if (file === void 0) throw new Error("Unsupported architecture: " + process.arch);
+	await download(resolveBase(version) + file, to);
+	fs.chmodSync(to, "755");
+	return to;
+}
+async function installMacos(to, version = CLOUDFLARED_VERSION) {
+	const file = MACOS_URL[process.arch];
+	if (file === void 0) throw new Error("Unsupported architecture: " + process.arch);
+	await download(resolveBase(version) + file, `${to}.tgz`);
+	if (process.env.DEBUG) console.log(`Extracting to ${to}`);
+	execSync(`tar -xzf ${path.basename(`${to}.tgz`)}`, { cwd: path.dirname(to) });
+	fs.unlinkSync(`${to}.tgz`);
+	fs.renameSync(`${path.dirname(to)}/cloudflared`, to);
+	return to;
+}
+async function installWindows(to, version = CLOUDFLARED_VERSION) {
+	const file = WINDOWS_URL[process.arch];
+	if (file === void 0) throw new Error("Unsupported architecture: " + process.arch);
+	await download(resolveBase(version) + file, to);
+	return to;
+}
+function download(url, to, redirect = 0) {
+	if (redirect === 0) {
+		if (process.env.DEBUG) console.log(`Downloading ${url} to ${to}`);
+	} else if (process.env.DEBUG) console.log(`Redirecting to ${url}`);
+	return new Promise((resolve, reject) => {
+		if (!fs.existsSync(path.dirname(to))) fs.mkdirSync(path.dirname(to), { recursive: true });
+		let done = true;
+		const file = fs.createWriteStream(to);
+		const request = https.get(url, (res) => {
+			if (res.statusCode === 302 && res.headers.location !== void 0) {
+				const redirection = res.headers.location;
+				done = false;
+				file.close(() => resolve(download(redirection, to, redirect + 1)));
+				return;
+			}
+			res.pipe(file);
+		});
+		file.on("finish", () => {
+			if (done) file.close(() => resolve(to));
+		});
+		request.on("error", (err) => {
+			fs.unlink(to, () => reject(err));
+		});
+		file.on("error", (err) => {
+			fs.unlink(to, () => reject(err));
+		});
+		request.end();
+	});
+}
+function startCloudflaredTunnel(options = {}, extraArgs = []) {
+	const args = ["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 (!options["--url"]) args.push("--url", "localhost:8080");
+	if (Array.isArray(extraArgs)) args.push(...extraArgs);
+	const child = spawn(cloudflaredBinPath, args, { stdio: [
+		"ignore",
+		"pipe",
+		"pipe"
+	] });
+	if (process.env.DEBUG) {
+		child.stdout.pipe(process.stdout);
+		child.stderr.pipe(process.stderr);
+	}
+	const urlRegex = /\|\s+(https?:\/\/\S+)/;
+	let urlResolver = () => void 0;
+	let urlRejector = () => void 0;
+	const url = new Promise((...pair) => [urlResolver, urlRejector] = pair);
+	url.catch(() => void 0);
+	const connectionResolvers = [];
+	const connectionRejectors = [];
+	const connections = [];
+	for (let i = 0; i < 1; i++) connections.push(new Promise((...pair) => [connectionResolvers[i], connectionRejectors[i]] = pair));
+	const recentOutput = [];
+	const parser = (data) => {
+		const str = data.toString();
+		for (const line of str.split("\n")) {
+			if (!line.trim()) continue;
+			recentOutput.push(line.trim());
+			if (recentOutput.length > 10) recentOutput.shift();
+		}
+		const urlMatch = str.match(urlRegex);
+		if (urlMatch) urlResolver(urlMatch[1]);
+		const connMatch = str.match(connRegex);
+		const ipMatch = str.match(ipRegex);
+		const locationMatch = str.match(locationRegex);
+		const indexMatch = str.match(indexRegex);
+		if (connMatch && ipMatch && locationMatch && indexMatch) {
+			const [, id] = connMatch;
+			const [, ip] = ipMatch;
+			const [, location] = locationMatch;
+			const [, idx] = indexMatch;
+			connectionResolvers[+idx]?.({
+				id,
+				ip,
+				location
+			});
+		}
+	};
+	child.stdout.on("data", parser).on("error", urlRejector);
+	child.stderr.on("data", parser).on("error", urlRejector);
+	child.on("error", urlRejector);
+	child.on("exit", (code, signal) => {
+		const reason = /* @__PURE__ */ new Error(`cloudflared exited (code=${code}, signal=${signal}) before URL was ready` + (recentOutput.length > 0 ? `\n\n${recentOutput.join("\n")}` : ""));
+		urlRejector(reason);
+		for (const reject of connectionRejectors) reject?.(reason);
+	});
+	const stop = async () => {
+		if (child.exitCode !== null || child.signalCode !== null) return;
+		const exited = once(child, "exit");
+		child.kill("SIGINT");
+		const killTimer = setTimeout(() => {
+			if (child.exitCode === null && child.signalCode === null) child.kill("SIGKILL");
+		}, 5e3);
+		try {
+			await exited;
+		} finally {
+			clearTimeout(killTimer);
+		}
+	};
+	return {
+		url,
+		connections,
+		child,
+		stop
+	};
+}
+export { cloudflaredBinPath, cloudflaredNotice, installCloudflared, startCloudflaredTunnel };

package/.output/server/node_modules/untun/dist/_chunks/log.mjs

@@ -0,0 +1,27 @@
+import { createInterface } from "node:readline/promises";
+function log(message, type) {
+	const color = type && colors[type];
+	console.log(color ? `${color}${message}${colors.reset}` : message);
+}
+async function prompt(message) {
+	if (!process.stdin.isTTY) return true;
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	try {
+		const answer = await rl.question(`${colors.info}?${colors.reset} ${message} ${colors.dim}(Y/n)${colors.reset} `);
+		return !/^n(o)?$/i.test(answer.trim());
+	} finally {
+		rl.close();
+	}
+}
+const colors = {
+	reset: "\x1B[0m",
+	dim: "\x1B[2m",
+	info: "\x1B[36m",
+	success: "\x1B[32m",
+	error: "\x1B[31m",
+	warn: "\x1B[33m"
+};
+export { log, prompt };

package/.output/server/node_modules/untun/dist/index.mjs

@@ -0,0 +1,47 @@
+import { log, prompt } from "./_chunks/log.mjs";
+import { existsSync } from "node:fs";
+import { constants } from "node:os";
+async function startTunnel(opts) {
+	const { installCloudflared, startCloudflaredTunnel, cloudflaredBinPath, cloudflaredNotice } = await import("./_chunks/cloudflared.mjs");
+	const url = opts.url || `${opts.protocol || "http"}://${opts.hostname ?? "localhost"}:${opts.port ?? 3e3}`;
+	log(`Starting cloudflared tunnel to ${url}`, "info");
+	if (!existsSync(cloudflaredBinPath)) {
+		log(cloudflaredNotice);
+		if (!(opts.acceptCloudflareNotice || process.env.UNTUN_ACCEPT_CLOUDFLARE_NOTICE || await prompt(`Do you agree with the above terms and wish to install the binary from GitHub?`))) {
+			log("Skipping tunnel setup.", "error");
+			return;
+		}
+		await installCloudflared();
+	}
+	const args = [["--url", url], opts.verifyTLS ? void 0 : ["--no-tls-verify", null]].filter(Boolean);
+	const tunnel = startCloudflaredTunnel(Object.fromEntries(args), opts.extraArgs);
+	let closed = false;
+	const signals = [
+		"SIGINT",
+		"SIGTERM",
+		"SIGHUP"
+	];
+	const handlers = /* @__PURE__ */ new Map();
+	const cleanup = async () => {
+		if (closed) return;
+		closed = true;
+		for (const [sig, handler] of handlers) process.off(sig, handler);
+		handlers.clear();
+		await tunnel.stop();
+	};
+	for (const signal of signals) {
+		const handler = () => {
+			cleanup().finally(() => {
+				const signo = constants.signals[signal] ?? 0;
+				process.exit(128 + signo);
+			});
+		};
+		handlers.set(signal, handler);
+		process.once(signal, handler);
+	}
+	return {
+		getURL: () => tunnel.url,
+		close: cleanup
+	};
+}
+export { startTunnel };

package/.output/server/node_modules/untun/package.json

@@ -0,0 +1,44 @@
+{
+  "name": "untun",
+  "version": "0.2.2",
+  "description": "Tunnel your local HTTP(s) server to the world! Powered by Cloudflare Quick Tunnels.",
+  "license": "MIT",
+  "repository": "unjs/untun",
+  "bin": {
+    "untun": "./dist/cli.mjs"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "types": "./dist/index.d.mts",
+  "exports": {
+    ".": "./dist/index.mjs"
+  },
+  "scripts": {
+    "build": "obuild",
+    "dev": "vitest dev",
+    "lint": "oxlint . && oxfmt --check src test",
+    "fmt": "oxlint . --fix && oxfmt src test",
+    "prepack": "pnpm run build",
+    "release": "pnpm test && pnpm build && changelogen --release && npm publish && git push --follow-tags",
+    "typecheck": "tsc --noEmit",
+    "test": "pnpm lint && pnpm typecheck &&  vitest run --coverage",
+    "untun": "node src/cli.ts"
+  },
+  "devDependencies": {
+    "@types/node": "^26.1.1",
+    "@vitest/coverage-v8": "^4.1.10",
+    "changelogen": "^0.6.2",
+    "eslint-config-unjs": "^0.6.2",
+    "obuild": "^0.4.38",
+    "oxfmt": "^0.59.0",
+    "oxlint": "^1.74.0",
+    "typescript": "^7.0.2",
+    "vitest": "^4.1.10"
+  },
+  "packageManager": "pnpm@11.15.1"
+}