Open a terminal in the browser

FROM node:24-trixie-slim

RUN apt-get update \
	&& apt-get install -y --no-install-recommends tmux \
	&& rm -rf /var/lib/apt/lists/*

# Scroll back with the mouse wheel, and keep more history.
RUN printf 'set -g mouse on\nset -g history-limit 50000\n' > /etc/tmux.conf

CMD ["sleep", "infinity"]

const INACTIVITY_TIMEOUT_MS = 5 * 60 * 1000;

export class MyContainer extends DurableObject<Env> {
	constructor(ctx: DurableObjectState, env: Env) {
		super(ctx, env);
		const container = ctx.container;
		if (container?.running) {
			void ctx.blockConcurrencyWhile(() =>
				container.setInactivityTimeout(INACTIVITY_TIMEOUT_MS),
			);
		}
	}
}

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

	async fetch(request: Request): Promise<Response> {
		const container = this.ctx.container;

		if (!container) {
			throw new Error("The container binding is not configured");
		}

		if (request.headers.get("Upgrade") !== "websocket") {
			return new Response("Expected a WebSocket upgrade", { status: 426 });
		}

		// tmux session names cannot contain "." or ":".
		const url = new URL(request.url);
		const session = url.searchParams.get("session") || "main";

		if (!/^[a-z0-9][a-z0-9-]{0,62}$/.test(session)) {
			return new Response("Invalid session name", { status: 400 });
		}

		if (!container.running) {
			container.start({
				image: container.images.terminal,
				// Block commands in the terminal from reaching the Internet
				enableInternet: false,
			});
			await container.setInactivityTimeout(INACTIVITY_TIMEOUT_MS);
		}

		// Attach to the tmux session, or create it. The session keeps the shell
		// running after this WebSocket closes.
		const abort = new AbortController();
		const tmux = await container.exec(
			["tmux", "new-session", "-A", "-s", session],
			{
				// Run the tmux client attached to a pseudo-terminal.
				pty: {
					cols: Number(url.searchParams.get("cols")) || 80,
					rows: Number(url.searchParams.get("rows")) || 24,
				},
				env: { TERM: "xterm-256color" },
				cwd: "/root",
				signal: abort.signal,
			},
		);

		const [client, server] = Object.values(new WebSocketPair());

		// Receive binary messages as ArrayBuffer instead of Blob.
		server.binaryType = "arraybuffer";

		// Keep this Durable Object in memory while the terminal is open.
		server.accept();

		const stdin = tmux.stdin!.getWriter();

		// Listeners must not throw. An exception closes the socket without running
		// the `close` listener, which leaves the tmux client running.
		server.addEventListener("message", (event) => {
			if (typeof event.data === "string") {
				try {
					const { cols, rows } = JSON.parse(event.data);
					tmux.resize(cols, rows);
				} catch {
					// Ignore malformed resize messages so the terminal keeps running.
				}
			} else {
				stdin.write(new Uint8Array(event.data)).catch(() => {});
			}
		});

		let exited = false;
		const markExited = () => {
			exited = true;
		};
		tmux.exitCode.then(markExited, markExited);

		// Stop the tmux client when the browser disconnects. The session and its
		// shell keep running.
		server.addEventListener("close", () => {
			// Signaling a process that has exited raises an error.
			if (!exited) abort.abort();
		});

		const forward = async () => {
			for await (const chunk of tmux.stdout!) {
				server.send(chunk);
			}

			server.close(1000, `Terminal closed with code ${await tmux.exitCode}`);
		};

		void forward().catch(() => server.close(1011, "Terminal output failed"));

		return new Response(null, { status: 101, webSocket: client });
	}
}