@rubriclab/bunl 0.1.25 → 0.2.0

package/e2e.test.ts

@@ -0,0 +1,189 @@
+import { afterAll, beforeAll, describe, expect, test } from 'bun:test'
+import type { Subprocess } from 'bun'
+
+const SERVER_PORT = 9100
+const DEMO_PORT = 9101
+const SUBDOMAIN = 'e2e'
+
+/**
+ * Make a request through the tunnel using Host-header routing.
+ * This avoids needing wildcard DNS (*.localhost) to resolve,
+ * which doesn't work in all environments.
+ */
+function tunnelFetch(path: string, init?: RequestInit): Promise<Response> {
+	const headers = new Headers(init?.headers as HeadersInit)
+	headers.set('host', `${SUBDOMAIN}.localhost:${SERVER_PORT}`)
+	return fetch(`http://localhost:${SERVER_PORT}${path}`, {
+		...init,
+		headers
+	})
+}
+
+let serverProc: Subprocess
+let demoProc: Subprocess
+let clientProc: Subprocess
+
+/** Wait until a URL responds (or timeout). */
+async function waitFor(url: string, timeoutMs = 10_000): Promise<void> {
+	const start = Date.now()
+	while (Date.now() - start < timeoutMs) {
+		try {
+			await fetch(url)
+			return
+		} catch {
+			await Bun.sleep(200)
+		}
+	}
+	throw new Error(`Timed out waiting for ${url}`)
+}
+
+/** Wait until a tunnel subdomain is connected (server returns non-404). */
+async function waitForTunnel(timeoutMs = 15_000): Promise<void> {
+	const start = Date.now()
+	while (Date.now() - start < timeoutMs) {
+		try {
+			const res = await tunnelFetch('/')
+			if (res.status !== 404) return
+		} catch {
+			// not ready yet
+		}
+		await Bun.sleep(300)
+	}
+	throw new Error('Timed out waiting for tunnel to be ready')
+}
+
+beforeAll(async () => {
+	// 1. Start the tunnel server
+	serverProc = Bun.spawn(['bun', 'run', 'server.ts'], {
+		cwd: import.meta.dir,
+		env: {
+			...process.env,
+			DOMAIN: `localhost:${SERVER_PORT}`,
+			PORT: String(SERVER_PORT),
+			SCHEME: 'http'
+		},
+		stderr: 'pipe',
+		stdout: 'pipe'
+	})
+
+	// 2. Start the demo webserver
+	demoProc = Bun.spawn(['bun', 'run', 'demo.ts'], {
+		cwd: import.meta.dir,
+		env: { ...process.env, DEMO_PORT: String(DEMO_PORT) },
+		stderr: 'pipe',
+		stdout: 'pipe'
+	})
+
+	// Wait for both to be up
+	await Promise.all([
+		waitFor(`http://localhost:${SERVER_PORT}/?new`),
+		waitFor(`http://localhost:${DEMO_PORT}/api/health`)
+	])
+
+	// 3. Start the tunnel client
+	clientProc = Bun.spawn(
+		[
+			'bun',
+			'run',
+			'client.ts',
+			'-p',
+			String(DEMO_PORT),
+			'-d',
+			`localhost:${SERVER_PORT}`,
+			'-s',
+			SUBDOMAIN
+		],
+		{
+			cwd: import.meta.dir,
+			env: process.env,
+			stderr: 'pipe',
+			stdout: 'pipe'
+		}
+	)
+
+	// Wait for the tunnel to be live
+	await waitForTunnel()
+})
+
+afterAll(() => {
+	clientProc?.kill()
+	demoProc?.kill()
+	serverProc?.kill()
+})
+
+describe('e2e tunnel', () => {
+	test('serves HTML through tunnel', async () => {
+		const res = await tunnelFetch('/')
+		expect(res.status).toBe(200)
+		expect(res.headers.get('content-type')).toContain('text/html')
+		const body = await res.text()
+		expect(body).toContain('<h1>bunl tunnel works!</h1>')
+	})
+
+	test('serves CSS through tunnel', async () => {
+		const res = await tunnelFetch('/style.css')
+		expect(res.status).toBe(200)
+		expect(res.headers.get('content-type')).toContain('text/css')
+		const body = await res.text()
+		expect(body).toContain('font-family')
+	})
+
+	test('serves PNG image (binary) through tunnel', async () => {
+		const res = await tunnelFetch('/image.png')
+		expect(res.status).toBe(200)
+		expect(res.headers.get('content-type')).toBe('image/png')
+		const buf = await res.arrayBuffer()
+		const bytes = new Uint8Array(buf)
+		// PNG magic bytes: 0x89 0x50 0x4E 0x47
+		expect(bytes[0]).toBe(0x89)
+		expect(bytes[1]).toBe(0x50)
+		expect(bytes[2]).toBe(0x4e)
+		expect(bytes[3]).toBe(0x47)
+	})
+
+	test('serves binary font through tunnel', async () => {
+		const res = await tunnelFetch('/font.woff2')
+		expect(res.status).toBe(200)
+		expect(res.headers.get('content-type')).toBe('font/woff2')
+		const buf = await res.arrayBuffer()
+		const bytes = new Uint8Array(buf)
+		// Our fake font is 256 bytes: [0, 1, 2, ..., 255]
+		expect(bytes.length).toBe(256)
+		expect(bytes[0]).toBe(0)
+		expect(bytes[127]).toBe(127)
+		expect(bytes[255]).toBe(255)
+	})
+
+	test('serves JSON API through tunnel', async () => {
+		const res = await tunnelFetch('/api/health')
+		expect(res.status).toBe(200)
+		const json = await res.json()
+		expect(json.status).toBe('ok')
+		expect(typeof json.timestamp).toBe('number')
+	})
+
+	test('handles POST with body through tunnel', async () => {
+		const payload = JSON.stringify({ hello: 'world' })
+		const res = await tunnelFetch('/echo', {
+			body: payload,
+			headers: { 'content-type': 'application/json' },
+			method: 'POST'
+		})
+		expect(res.status).toBe(200)
+		const body = await res.text()
+		expect(body).toBe(payload)
+	})
+
+	test("concurrent requests don't collide", async () => {
+		const paths = ['/', '/style.css', '/image.png', '/api/health', '/font.woff2']
+		const results = await Promise.all(paths.map(p => tunnelFetch(p).then(r => r.status)))
+		expect(results).toEqual([200, 200, 200, 200, 200])
+	})
+
+	test('returns 404 for unknown subdomain', async () => {
+		const res = await fetch(`http://localhost:${SERVER_PORT}/`, {
+			headers: { host: `nonexistent.localhost:${SERVER_PORT}` }
+		})
+		expect(res.status).toBe(404)
+	})
+})

package/package.json

@@ -1,46 +1,49 @@
 {
-  "bin": {
-    "bunl": "build/client.js"
-  },
-  "name": "@rubriclab/bunl",
-  "description": "Expose localhost to the world",
-  "version": "0.1.25",
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "git+https://github.com/RubricLab/bunl.git"
-  },
-  "dependencies": {
-    "human-id": "^4.1.1",
-    "open": "^10.1.0"
-  },
-  "devDependencies": {
-    "@rubriclab/typescript-config": "^1.0.0",
-    "@types/bun": "latest"
-  },
-  "main": "build/client.js",
-  "scripts": {
-    "server": "bun server.ts",
-    "dev:server": "bun --watch server.ts",
-    "client": "bun --watch client.ts",
-    "demo": "bun --watch demo.ts",
-    "client:upgrade": "bun rm -g @rubriclab/bunl && bun i -g @rubriclab/bunl@latest",
-    "build": "BUILD=build/client.js && bun build client.ts --outdir build --target bun && echo -e \"#! /usr/bin/env bun\n$(cat $BUILD)\" > $BUILD",
-    "npm:publish": "bun run build && npm publish"
-  },
-  "type": "module",
-  "peerDependencies": {
-    "typescript": "^5.0.0"
-  },
-  "publishConfig": {
-    "@RubricLab:registry": "https://registry.npmjs.org",
-    "access": "public",
-    "registry": "https://registry.npmjs.org"
-  },
-  "homepage": "https://github.com/RubricLab/bunl#readme",
-  "keywords": [
-    "local",
-    "tunnel",
-    "rubric"
-  ]
+	"bin": {
+		"bunl": "build/client.js"
+	},
+	"dependencies": {
+		"@rubriclab/config": "^0.0.24"
+	},
+	"description": "Expose localhost to the world. Bun-native localtunnel.",
+	"devDependencies": {
+		"@rubriclab/package": "^0.0.124",
+		"@types/bun": "latest"
+	},
+	"homepage": "https://github.com/RubricLab/bunl#readme",
+	"keywords": [
+		"local",
+		"tunnel",
+		"bun",
+		"websocket"
+	],
+	"license": "MIT",
+	"main": "build/client.js",
+	"name": "@rubriclab/bunl",
+	"publishConfig": {
+		"access": "public"
+	},
+	"repository": {
+		"type": "git",
+		"url": "git+https://github.com/RubricLab/bunl.git"
+	},
+	"scripts": {
+		"bleed": "bun x npm-check-updates -u",
+		"build": "bun build client.ts --outdir build --target bun && printf '#! /usr/bin/env bun\\n%s' \"$(cat build/client.js)\" > build/client.js",
+		"clean": "rm -rf .next && rm -rf node_modules",
+		"client": "bun --watch client.ts",
+		"demo": "bun --watch demo.ts",
+		"dev:server": "bun --watch server.ts",
+		"format": "bun x biome format --write .",
+		"lint": "bun x biome check .",
+		"lint:fix": "bun x biome lint . --write --unsafe",
+		"server": "bun server.ts",
+		"test": "bun test",
+		"test:e2e": "bun test e2e.test.ts"
+	},
+	"simple-git-hooks": {
+		"post-commit": "rubriclab-package post-commit"
+	},
+	"type": "module",
+	"version": "0.2.0"
 }

package/server.ts

@@ -1,87 +1,150 @@
-import { serve, type ServerWebSocket } from "bun";
-import { uid } from "./utils";
-import type { Client, Payload } from "./types";
+import { type ServerWebSocket, serve } from 'bun'
+import type { Client, TunnelInit, TunnelRequest, TunnelResponse } from './types'
+import { fromBase64, toBase64, uid } from './utils'
 
-const port = Bun.env.PORT || 1234;
-const scheme = Bun.env.SCHEME || "http";
-const domain = Bun.env.DOMAIN || `localhost:${port}`;
+const port = Number(Bun.env.PORT) || 1234
+const scheme = Bun.env.SCHEME || 'http'
+const domain = Bun.env.DOMAIN || `localhost:${port}`
 
-const clients = new Map<string, ServerWebSocket<Client>>();
-const requesters = new Map<string, WritableStream>();
+/** The hostname portion of DOMAIN (no port) used for subdomain extraction */
+const domainHost = domain.replace(/:\d+$/, '')
+
+/** Connected tunnel clients keyed by subdomain */
+const clients = new Map<string, ServerWebSocket<Client>>()
+
+/** Pending HTTP requests waiting for a tunnel response, keyed by request ID */
+const pending = new Map<
+	string,
+	{
+		resolve: (res: TunnelResponse) => void
+		timer: Timer
+	}
+>()
+
+const TIMEOUT_MS = 30_000
 
 serve<Client>({
-  port,
-  fetch: async (req, server) => {
-    const reqUrl = new URL(req.url);
-
-    if (reqUrl.searchParams.has("new")) {
-      const requested = reqUrl.searchParams.get("subdomain");
-      let id = requested || uid();
-      if (clients.has(id)) id = uid();
-
-      const upgraded = server.upgrade(req, { data: { id } });
-      if (upgraded) return;
-      else return new Response("upgrade failed", { status: 500 });
-    }
-
-    const subdomain = reqUrl.hostname.split(".")[0];
-
-    if (!clients.has(subdomain)) {
-      return new Response(`${subdomain} not found`, { status: 404 });
-    }
-
-    // The magic: forward the req to the client
-    const client = clients.get(subdomain)!;
-    const { method, url, headers: reqHeaders } = req;
-    const reqBody = await req.text();
-    const pathname = new URL(url).pathname;
-    const payload: Payload = {
-      method,
-      pathname,
-      body: reqBody,
-      headers: reqHeaders,
-    };
-
-    const { writable, readable } = new TransformStream();
-
-    requesters.set(`${method}:${subdomain}${pathname}`, writable);
-    client.send(JSON.stringify(payload));
-
-    const res = await readable.getReader().read();
-    const { status, statusText, headers, body } = JSON.parse(res.value);
-
-    delete headers["content-encoding"]; // remove problematic header
-
-    return new Response(body, { status, statusText, headers });
-  },
-  websocket: {
-    open(ws) {
-      clients.set(ws.data.id, ws);
-      console.log(`\x1b[32m+ ${ws.data.id} (${clients.size} total)\x1b[0m`);
-      ws.send(
-        JSON.stringify({
-          url: `${scheme}://${ws.data.id}.${domain}`,
-        })
-      );
-    },
-    message: async ({ data: { id } }, message: string) => {
-      console.log("message from", id);
-
-      const { method, pathname } = JSON.parse(message) as Payload;
-      const writable = requesters.get(`${method}:${id}${pathname}`);
-      if (!writable) throw "connection not found";
-
-      if (writable.locked) return;
-
-      const writer = writable.getWriter();
-      await writer.write(message);
-      await writer.close();
-    },
-    close({ data }) {
-      console.log("closing", data.id);
-      clients.delete(data.id);
-    },
-  },
-});
-
-console.log(`websocket server up at ws://${domain}`);
+	fetch: async (req, server) => {
+		const reqUrl = new URL(req.url)
+
+		// Client wants to register a new tunnel
+		if (reqUrl.searchParams.has('new')) {
+			const requested = reqUrl.searchParams.get('subdomain')
+			let id = requested || uid()
+			// Avoid collisions — if taken, generate a fresh one
+			if (clients.has(id)) id = uid()
+
+			const upgraded = server.upgrade(req, { data: { id } })
+			if (upgraded) return undefined
+			return new Response('WebSocket upgrade failed', { status: 500 })
+		}
+
+		// Public HTTP request — route to the right tunnel client.
+		// Use the Host header (not reqUrl.hostname) so this works behind
+		// reverse proxies like Fly.io where reqUrl.hostname is internal.
+		// Strip the DOMAIN suffix to extract the tunnel subdomain, so it
+		// works when the server is itself on a subdomain (e.g. bunl.rubric.sh).
+		const host = (req.headers.get('host') || reqUrl.hostname).replace(/:\d+$/, '')
+		const subdomain = host.endsWith(`.${domainHost}`) ? host.slice(0, -(domainHost.length + 1)) : ''
+		const client = subdomain ? clients.get(subdomain) : undefined
+
+		if (!client) {
+			return new Response(`Tunnel "${subdomain}" not found`, { status: 404 })
+		}
+
+		const id = crypto.randomUUID()
+		const { method } = req
+		const pathname = reqUrl.pathname + reqUrl.search
+
+		// Read request body as binary and encode to base64
+		const rawBody = await req.arrayBuffer()
+		const body = rawBody.byteLength > 0 ? toBase64(rawBody) : ''
+
+		// Flatten request headers
+		const headers: Record<string, string> = {}
+		req.headers.forEach((v, k) => {
+			headers[k] = v
+		})
+
+		const message: TunnelRequest = {
+			body,
+			headers,
+			id,
+			method,
+			pathname,
+			type: 'request'
+		}
+
+		// Create a promise that will be resolved when the client responds
+		const response = await new Promise<TunnelResponse>((resolve, reject) => {
+			const timer = setTimeout(() => {
+				pending.delete(id)
+				reject(new Error('Tunnel request timed out'))
+			}, TIMEOUT_MS)
+
+			pending.set(id, { resolve, timer })
+			client.send(JSON.stringify(message))
+		}).catch((err: unknown): TunnelResponse => {
+			const message = err instanceof Error ? err.message : String(err)
+			return {
+				body: Buffer.from(message).toString('base64'),
+				headers: { 'content-type': 'text/plain' },
+				id,
+				status: 504,
+				statusText: 'Gateway Timeout',
+				type: 'response'
+			}
+		})
+
+		// Decode base64 response body back to binary
+		const resBody = response.body ? fromBase64(response.body) : null
+
+		// Build response headers, removing problematic ones
+		const resHeaders = { ...response.headers }
+		delete resHeaders['content-encoding']
+		delete resHeaders['transfer-encoding']
+		// Fix content-length to match the actual decoded body
+		if (resBody) {
+			resHeaders['content-length'] = String(resBody.byteLength)
+		}
+
+		return new Response(resBody as Uint8Array<ArrayBuffer> | null, {
+			headers: resHeaders,
+			status: response.status,
+			statusText: response.statusText
+		})
+	},
+	port,
+	websocket: {
+		close(ws) {
+			console.log(`\x1b[31m- ${ws.data.id}\x1b[0m (${clients.size - 1} connected)`)
+			clients.delete(ws.data.id)
+		},
+
+		message(_ws, raw) {
+			const msg = JSON.parse(
+				typeof raw === 'string' ? raw : new TextDecoder().decode(raw)
+			) as TunnelResponse
+
+			if (msg.type !== 'response' || !msg.id) return
+
+			const entry = pending.get(msg.id)
+			if (!entry) return
+
+			clearTimeout(entry.timer)
+			pending.delete(msg.id)
+			entry.resolve(msg)
+		},
+		open(ws) {
+			clients.set(ws.data.id, ws)
+			console.log(`\x1b[32m+ ${ws.data.id}\x1b[0m (${clients.size} connected)`)
+			const init: TunnelInit = {
+				type: 'init',
+				url: `${scheme}://${ws.data.id}.${domain}`
+			}
+			ws.send(JSON.stringify(init))
+		}
+	}
+})
+
+console.log(`bunl server listening on :${port} (${scheme}://*.${domain})`)

package/tsconfig.json

@@ -1,5 +1,5 @@
 {
-  "compilerOptions": { "baseUrl": "." },
-  "exclude": ["node_modules"],
-  "extends": "@rubriclab/typescript-config/base"
+	"exclude": ["node_modules"],
+	"extends": "@rubriclab/config/tsconfig",
+	"include": ["**/*.ts"]
 }

package/types.ts

@@ -1,10 +1,27 @@
-export type Client = { id: string };
+export type Client = { id: string }
 
-export type Payload = {
-  status?: number;
-  statusText?: string;
-  method?: string;
-  pathname?: string;
-  body: string;
-  headers: object;
-};
+/** Server → Client: incoming HTTP request to proxy */
+export type TunnelRequest = {
+	type: 'request'
+	id: string
+	method: string
+	pathname: string
+	headers: Record<string, string>
+	body: string // base64-encoded
+}
+
+/** Client → Server: proxied HTTP response */
+export type TunnelResponse = {
+	type: 'response'
+	id: string
+	status: number
+	statusText: string
+	headers: Record<string, string>
+	body: string // base64-encoded
+}
+
+/** Server → Client: initial connection info */
+export type TunnelInit = {
+	type: 'init'
+	url: string
+}