在浏览器中打开终端

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("No container is 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 });
    }
}