Move preview URLs

type PortToken = { token: string; name?: string };
type Stored = Record<string, string | PortToken>;

// The key where 0.12 stored preview tokens.
const PORT_TOKENS = "portTokens";

function previewUrl(
	port: number,
	name: string,
	token: string,
	hostname: string,
): string {
	return `https://${port}-${name}-${token}.${hostname}/`;
}

// 16 characters from [a-z0-9_], as 0.12 generated them.
function generateToken(): string {
	const bytes = crypto.getRandomValues(new Uint8Array(12));
	return btoa(String.fromCharCode(...bytes))
		.replace(/[+/]/g, "_")
		.toLowerCase();
}

export class MySandbox extends DurableObject<Env> {
	// ...

	private async readPortTokens(): Promise<Record<string, PortToken>> {
		const stored = await this.ctx.storage.get<Stored>(PORT_TOKENS);
		const tokens: Record<string, PortToken> = {};

		// Early 0.12 versions stored the token as a string.
		for (const [port, value] of Object.entries(stored ?? {})) {
			tokens[port] =
				typeof value === "string" ? { token: value } : value;
		}

		return tokens;
	}

	async exposePort(
		sandboxName: string,
		port: number,
		options: { hostname: string; name?: string; token?: string },
	) {
		if (!Number.isInteger(port) || port < 1024 || port > 65535) {
			throw new Error(`Invalid port number: ${port}`);
		}

		if (options.token && !/^[a-z0-9_]{1,16}$/.test(options.token)) {
			throw new Error(`Invalid token: ${options.token}`);
		}

		const tokens = await this.readPortTokens();
		const token =
			options.token ?? tokens[port]?.token ?? generateToken();
		tokens[port] = { token, name: options.name };
		await this.ctx.storage.put(PORT_TOKENS, tokens);

		return {
			url: previewUrl(port, sandboxName, token, options.hostname),
			port,
			name: options.name,
		};
	}
}

const sandbox = env.Sandbox.getByName(name);
const { url } = await sandbox.exposePort(name, 8080, {
	hostname: "example.com",
});

export class MySandbox extends DurableObject<Env> {
	// ...

	async unexposePort(port: number): Promise<void> {
		const tokens = await this.readPortTokens();
		delete tokens[port];
		await this.ctx.storage.put(PORT_TOKENS, tokens);
	}

	async getExposedPorts(sandboxName: string, hostname: string) {
		const tokens = await this.readPortTokens();

		return Object.entries(tokens).map(([port, { token }]) => ({
			url: previewUrl(Number(port), sandboxName, token, hostname),
			port: Number(port),
			status: "active" as const,
		}));
	}

	async isPortExposed(port: number): Promise<boolean> {
		const tokens = await this.readPortTokens();
		return port in tokens;
	}

	async validatePortToken(
		port: number,
		token: string,
	): Promise<boolean> {
		const tokens = await this.readPortTokens();
		const expected = tokens[port]?.token;

		if (expected === undefined) {
			return false;
		}

		// Compare in constant time, so timing does not reveal the token.
		const encoder = new TextEncoder();
		const a = encoder.encode(expected);
		const b = encoder.encode(token);

		if (a.byteLength !== b.byteLength) {
			return false;
		}

		return crypto.subtle.timingSafeEqual(a, b);
	}
}

export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		const proxied = await proxyToSandbox(request, env);

		if (proxied) {
			return proxied;
		}

		// Your other routes.
	},
};

// <port>-<sandbox name>-<token>, as 0.12 issued preview hostnames.
const PREVIEW = /^(\d{4,5})-([a-z0-9-]{1,63})-([a-z0-9_]{1,63})\./;

// The Durable Object forwards to the port in this header.
function toPort(request: Request, port: number): Request {
	const headers = new Headers(request.headers);
	headers.set("X-Sandbox-Port", String(port));
	return new Request(request, { headers });
}

export default {
	async fetch(request: Request, env: Env): Promise<Response> {
		const url = new URL(request.url);
		const preview = PREVIEW.exec(url.hostname);

		if (preview) {
			const [, portText, name, token] = preview;
			const port = Number(portText);
			const sandbox = env.Sandbox.getByName(name);

			if (!(await sandbox.validatePortToken(port, token))) {
				return new Response("Not found", { status: 404 });
			}

			return sandbox.fetch(toPort(request, port));
		}

		// Your other routes.
	},
} satisfies ExportedHandler<Env>;

export class MySandbox extends DurableObject<Env> {
	// ...

	async fetch(request: Request): Promise<Response> {
		const container = this.ctx.container;
		const port = Number(request.headers.get("X-Sandbox-Port"));

		// Preview requests do not start the container.
		if (!container?.running) {
			return new Response("The sandbox is not running", {
				status: 503,
			});
		}

		const url = new URL(request.url);
		url.protocol = "http:";
		const forwarded = new Request(url, request);
		forwarded.headers.delete("X-Sandbox-Port");

		try {
			const tcpPort = container.getTcpPort(port);
			const response = await tcpPort.fetch(forwarded);

			if (response.webSocket) {
				return bridge(response.webSocket);
			}

			return response;
		} catch {
			return new Response("Nothing is listening on this port", {
				status: 503,
			});
		}
	}
}

if (request.headers.get("Upgrade") === "websocket") {
	return getSandbox(env.Sandbox, name).wsConnect(request, 8080);
}

if (request.headers.get("Upgrade") === "websocket") {
	return env.Sandbox.getByName(name).fetch(toPort(request, 8080));
}