Function handleVLESS

cfworker/worker.js:59–125

* Handle a VLESS-over-WebSocket upgrade. * Minimal VLESS implementation; supports TCP outbound only (no UDP / Mux).

(request, uuid)

 * Minimal VLESS implementation; supports TCP outbound only (no UDP / Mux).
 */
async function handleVLESS(request, uuid) {
  const pair = new WebSocketPair();
  const [client, ws] = Object.values(pair);
  ws.accept();

  // Read the early-data header so the first packet is part of the upgrade.
  const earlyData = b64UrlToUint8(request.headers.get("sec-websocket-protocol") || "");

  // We buffer incoming WebSocket messages until we've parsed the VLESS
  // header; after that each message is piped raw to the remote socket.
  const handshake = { parsed: false, remote: null, writer: null };

  const onMessage = async (data) => {
    const chunk = toUint8(data);
    if (!handshake.parsed) {
      const parsed = parseVLESSHeader(chunk, uuid);
      if (!parsed.ok) {
        console.log("vless header parse failed:", parsed.err);
        safeClose(ws);
        return;
      }
      handshake.parsed = true;

      // Open the upstream TCP connection (Cloudflare 'connect' API).
      const socket = await cfConnect(parsed.host, parsed.port);
      handshake.remote = socket;
      handshake.writer = socket.writable.getWriter();

      // VLESS server reply: version 0, addons length 0.
      ws.send(new Uint8Array([parsed.version, 0]).buffer);

      // Forward any payload that came after the header.
      if (parsed.payload.length > 0) {
        await handshake.writer.write(parsed.payload);
      }
      // Pipe server -> WS.
      socket.readable
        .pipeTo(new WritableStream({
          write(data) {
            if (ws.readyState === WS_READY_STATE_OPEN) {
              ws.send(data);
            }
          },
          close() { safeClose(ws); },
          abort() { safeClose(ws); },
        }))
        .catch(() => safeClose(ws));
      return;
    }
    // Subsequent WS messages → remote socket.
    try {
      await handshake.writer.write(chunk);
    } catch {
      safeClose(ws);
    }
  };

  ws.addEventListener("message", (ev) => { onMessage(ev.data); });