quickwin 2026.5.2-3.145209

package/lib/websocket.js

@@ -0,0 +1,540 @@
+import '../lib/polyfill.js';
+import * as sock from 'sock';
+import * as wolfssl from 'wolfssl';
+import * as os from 'os';
+// ── Constants ──
+const MAGIC_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
+var State;
+(function (State) {
+    State[State["CONNECTING"] = 0] = "CONNECTING";
+    State[State["OPEN"] = 1] = "OPEN";
+    State[State["CLOSING"] = 2] = "CLOSING";
+    State[State["CLOSED"] = 3] = "CLOSED";
+})(State || (State = {}));
+var Opcode;
+(function (Opcode) {
+    Opcode[Opcode["CONTINUATION"] = 0] = "CONTINUATION";
+    Opcode[Opcode["TEXT"] = 1] = "TEXT";
+    Opcode[Opcode["BINARY"] = 2] = "BINARY";
+    Opcode[Opcode["CLOSE"] = 8] = "CLOSE";
+    Opcode[Opcode["PING"] = 9] = "PING";
+    Opcode[Opcode["PONG"] = 10] = "PONG";
+})(Opcode || (Opcode = {}));
+// ── Random key generation ──
+function generateKey() {
+    const bytes = new Uint8Array(16);
+    crypto.getRandomValues(bytes);
+    return btoa(String.fromCharCode(...bytes));
+}
+async function computeAccept(key) {
+    const data = new TextEncoder().encode(key + MAGIC_GUID);
+    const hash = await crypto.subtle.digest('SHA-1', data);
+    const hashBytes = new Uint8Array(hash);
+    return btoa(String.fromCharCode(...hashBytes));
+}
+// ── Frame helpers ──
+function createFrame(opcode, payload) {
+    const maskingKey = new Uint8Array(4);
+    for (let i = 0; i < 4; i++)
+        maskingKey[i] = (Math.random() * 256) | 0;
+    let headerSize;
+    if (payload.length < 126) {
+        headerSize = 6;
+    }
+    else if (payload.length < 65536) {
+        headerSize = 8;
+    }
+    else {
+        headerSize = 14;
+    }
+    const buf = new ArrayBuffer(headerSize + payload.length);
+    const view = new Uint8Array(buf);
+    let off = 0;
+    view[off++] = 0x80 | opcode;
+    view[off++] = 0x80 | (payload.length < 126 ? payload.length :
+        payload.length < 65536 ? 126 : 127);
+    if (payload.length >= 126 && payload.length < 65536) {
+        view[off++] = (payload.length >> 8) & 0xFF;
+        view[off++] = payload.length & 0xFF;
+    }
+    else if (payload.length >= 65536) {
+        const len = payload.length;
+        const hi = Math.floor(len / 0x100000000) >>> 0;
+        const lo = len >>> 0;
+        view[off++] = (hi >> 24) & 0xFF;
+        view[off++] = (hi >> 16) & 0xFF;
+        view[off++] = (hi >> 8) & 0xFF;
+        view[off++] = hi & 0xFF;
+        view[off++] = (lo >> 24) & 0xFF;
+        view[off++] = (lo >> 16) & 0xFF;
+        view[off++] = (lo >> 8) & 0xFF;
+        view[off++] = lo & 0xFF;
+    }
+    view[off++] = maskingKey[0];
+    view[off++] = maskingKey[1];
+    view[off++] = maskingKey[2];
+    view[off++] = maskingKey[3];
+    for (let i = 0; i < payload.length; i++) {
+        view[off++] = payload[i] ^ maskingKey[i % 4];
+    }
+    return buf;
+}
+function createCloseFrame(code, reason) {
+    const reasonBytes = new Uint8Array(reason.length + 2);
+    reasonBytes[0] = (code >> 8) & 0xFF;
+    reasonBytes[1] = code & 0xFF;
+    for (let i = 0; i < reason.length; i++) {
+        reasonBytes[i + 2] = reason.charCodeAt(i) & 0xFF;
+    }
+    return createFrame(Opcode.CLOSE, reasonBytes);
+}
+function tryParseFrame(buffer) {
+    if (buffer.length < 2)
+        return null;
+    const b0 = buffer[0];
+    const b1 = buffer[1];
+    const fin = (b0 & 0x80) !== 0;
+    const opcode = b0 & 0x0F;
+    const masked = (b1 & 0x80) !== 0;
+    let payloadLen = b1 & 0x7F;
+    let offset = 2;
+    if (payloadLen === 126) {
+        if (buffer.length < 4)
+            return null;
+        payloadLen = (buffer[2] << 8) | buffer[3];
+        offset = 4;
+    }
+    else if (payloadLen === 127) {
+        if (buffer.length < 10)
+            return null;
+        let hi = 0, lo = 0;
+        for (let i = 0; i < 4; i++)
+            hi = (hi * 256 + buffer[offset + i]) >>> 0;
+        for (let i = 4; i < 8; i++)
+            lo = (lo * 256 + buffer[offset + i]) >>> 0;
+        payloadLen = hi * 0x100000000 + lo;
+        offset = 10;
+    }
+    if (masked)
+        offset += 4;
+    const totalLen = offset + payloadLen;
+    if (buffer.length < totalLen)
+        return null;
+    let payload;
+    if (masked) {
+        const maskKey = buffer.slice(offset - 4, offset);
+        payload = new Uint8Array(payloadLen);
+        for (let i = 0; i < payloadLen; i++) {
+            payload[i] = buffer[offset + i] ^ maskKey[i % 4];
+        }
+    }
+    else {
+        payload = buffer.slice(offset, offset + payloadLen);
+    }
+    return { opcode, payload, fin, totalLen };
+}
+class WebSocket {
+    url;
+    readyState = State.CONNECTING;
+    onopen = null;
+    onclose = null;
+    onerror = null;
+    onmessage = null;
+    _sock = null;
+    _ssl = null;
+    _ctx = null;
+    _readBuffer = new Uint8Array(0);
+    _state = State.CONNECTING;
+    _resolveOpen = null;
+    _processingHandshake = false;
+    static CONNECTING = State.CONNECTING;
+    static OPEN = State.OPEN;
+    static CLOSING = State.CLOSING;
+    static CLOSED = State.CLOSED;
+    _closeCode = 1005;
+    _closeReason = '';
+    _requestKey = '';
+    constructor(url) {
+        this.url = url;
+        this._connect();
+    }
+    send(data) {
+        if (this._state !== State.OPEN)
+            return;
+        let payload;
+        if (typeof data === 'string') {
+            const bytes = [];
+            for (let i = 0; i < data.length; i++) {
+                const c = data.charCodeAt(i);
+                if (c < 0x80) {
+                    bytes.push(c);
+                }
+                else if (c < 0x800) {
+                    bytes.push(0xC0 | (c >> 6), 0x80 | (c & 0x3F));
+                }
+                else {
+                    bytes.push(0xE0 | (c >> 12), 0x80 | ((c >> 6) & 0x3F), 0x80 | (c & 0x3F));
+                }
+            }
+            payload = new Uint8Array(bytes);
+            const frame = createFrame(Opcode.TEXT, payload);
+            this._sendRaw(frame);
+        }
+        else if (data instanceof ArrayBuffer) {
+            payload = new Uint8Array(data);
+            const frame = createFrame(Opcode.BINARY, payload);
+            this._sendRaw(frame);
+        }
+        else if (data instanceof Uint8Array) {
+            const frame = createFrame(Opcode.BINARY, data);
+            this._sendRaw(frame);
+        }
+    }
+    close(code, reason) {
+        if (this._state === State.CLOSED || this._state === State.CLOSING)
+            return;
+        this._state = State.CLOSING;
+        const closeCode = code || 1000;
+        const closeReason = reason || '';
+        this._closeCode = closeCode;
+        this._closeReason = closeReason;
+        const frame = createCloseFrame(closeCode, closeReason);
+        this._sendRaw(frame);
+        this._cleanup();
+        this._setState(State.CLOSED);
+    }
+    _connect() {
+        let url;
+        try {
+            url = new URL(this.url);
+        }
+        catch {
+            const self = this;
+            os.setTimeout(() => {
+                self._fireError(new Error('Invalid WebSocket URL: ' + self.url));
+                self._setState(State.CLOSED);
+            }, 0);
+            return;
+        }
+        const host = url.hostname;
+        const isWSS = url.protocol === 'wss:';
+        const port = url.port ? parseInt(url.port, 10) : (isWSS ? 443 : 80);
+        const path = url.pathname;
+        const requestKey = generateKey();
+        this._requestKey = requestKey;
+        const request = ('GET ' + path + ' HTTP/1.1\r\n' +
+            'Host: ' + host + ':' + port + '\r\n' +
+            'Upgrade: websocket\r\n' +
+            'Connection: Upgrade\r\n' +
+            'Sec-WebSocket-Key: ' + requestKey + '\r\n' +
+            'Sec-WebSocket-Version: 13\r\n' +
+            '\r\n');
+        let state = 'resolve';
+        let headerBuffer = '';
+        let resolved = false;
+        const cleanup = () => {
+            if (this._ssl) {
+                wolfssl.wolfSSL_free(this._ssl);
+                this._ssl = null;
+            }
+            if (this._ctx) {
+                wolfssl.wolfSSL_CTX_free(this._ctx);
+                this._ctx = null;
+            }
+            if (this._sock) {
+                sock.closesocket(this._sock);
+                this._sock = null;
+            }
+        };
+        const doError = (err) => {
+            if (resolved)
+                return;
+            resolved = true;
+            cleanup();
+            this._fireError(err);
+            if (this._state !== State.CLOSED)
+                this._setState(State.CLOSED);
+        };
+        this._sock = sock.socket();
+        if (!this._sock) {
+            const self = this;
+            os.setTimeout(() => {
+                self._fireError(new Error('Failed to create socket'));
+                if (self._state !== State.CLOSED)
+                    self._setState(State.CLOSED);
+            }, 0);
+            return;
+        }
+        const fd = this._sock;
+        sock.set_on_event(fd, async (event) => {
+            if (this._processingHandshake)
+                return;
+            if (resolved && state === 'open') {
+                if (event.lNetworkEvents & sock.FD_READ) {
+                    this._onData();
+                }
+                if (event.lNetworkEvents & sock.FD_CLOSE) {
+                    this._cleanup();
+                    this._setState(State.CLOSED);
+                }
+                return;
+            }
+            if (event.lNetworkEvents & sock.FD_CONNECT) {
+                const errCode = event.iErrorCode[0];
+                if (errCode !== 0) {
+                    doError(new Error('Connection failed: ' + errCode));
+                    return;
+                }
+                if (isWSS) {
+                    const method = wolfssl.wolfTLSv1_2_client_method();
+                    this._ctx = wolfssl.wolfSSL_CTX_new(method);
+                    wolfssl.wolfSSL_CTX_set_verify(this._ctx, wolfssl.SSL_VERIFY_NONE);
+                    this._ssl = wolfssl.wolfSSL_new(this._ctx);
+                    if (!this._ssl) {
+                        doError(new Error('SSL_new failed'));
+                        return;
+                    }
+                    wolfssl.wolfSSL_set_fd(this._ssl, sock.get_fd(fd));
+                    const sniHost = host;
+                    if (sniHost)
+                        wolfssl.wolfSSL_UseSNI(this._ssl, wolfssl.WOLFSSL_SNI_HOST_NAME, sniHost);
+                    state = 'handshake';
+                }
+                else {
+                    this._sendRawStr(request);
+                    state = 'request';
+                }
+            }
+            if ((event.lNetworkEvents & sock.FD_READ) || (event.lNetworkEvents & sock.FD_WRITE)) {
+                if (state === 'handshake') {
+                    if (!this._ssl) {
+                        doError(new Error('TLS not initialized'));
+                        return;
+                    }
+                    const ret = wolfssl.wolfSSL_connect(this._ssl);
+                    if (ret === wolfssl.SSL_SUCCESS) {
+                        this._sendRawStr(request);
+                        state = 'request';
+                    }
+                    else {
+                        const err = wolfssl.wolfSSL_get_error(this._ssl, ret);
+                        if (err !== wolfssl.WOLFSSL_ERROR_WANT_READ &&
+                            err !== wolfssl.WOLFSSL_ERROR_WANT_WRITE) {
+                            doError(new Error('TLS handshake failed: ' + err));
+                        }
+                    }
+                }
+                else if (state === 'request') {
+                    while (true) {
+                        let data;
+                        if (isWSS && this._ssl) {
+                            data = wolfssl.wolfSSL_read(this._ssl, 8192);
+                        }
+                        else if (this._sock) {
+                            data = sock.recv(this._sock, 8192);
+                        }
+                        else {
+                            break;
+                        }
+                        if (!data || data.byteLength === 0)
+                            break;
+                        headerBuffer += _ab2str(data);
+                        const headerEnd = headerBuffer.indexOf('\r\n\r\n');
+                        if (headerEnd >= 0) {
+                            const headerPart = headerBuffer.slice(0, headerEnd);
+                            const lines = headerPart.split('\r\n');
+                            const statusLine = lines[0];
+                            const statusParts = statusLine.split(' ');
+                            const statusCode = parseInt(statusParts[1], 10);
+                            if (statusCode !== 101) {
+                                doError(new Error('WebSocket handshake failed: HTTP ' + statusCode));
+                                return;
+                            }
+                            let acceptHeader = '';
+                            for (let i = 1; i < lines.length; i++) {
+                                const line = lines[i];
+                                const colonIdx2 = line.indexOf(':');
+                                if (colonIdx2 >= 0) {
+                                    const name = line.slice(0, colonIdx2).toLowerCase().trim();
+                                    if (name === 'sec-websocket-accept') {
+                                        acceptHeader = line.slice(colonIdx2 + 1).trim();
+                                        break;
+                                    }
+                                }
+                            }
+                            if (!acceptHeader) {
+                                doError(new Error('WebSocket handshake missing Sec-WebSocket-Accept'));
+                                return;
+                            }
+                            this._processingHandshake = true;
+                            const expectedAccept = await computeAccept(requestKey);
+                            if (acceptHeader !== expectedAccept) {
+                                doError(new Error('WebSocket handshake invalid Sec-WebSocket-Accept'));
+                                this._processingHandshake = false;
+                                return;
+                            }
+                            state = 'open';
+                            resolved = true;
+                            this._processingHandshake = false;
+                            this._setState(State.OPEN);
+                            break;
+                        }
+                    }
+                }
+            }
+            if (event.lNetworkEvents & sock.FD_CLOSE) {
+                if (state !== 'open') {
+                    doError(new Error('Connection closed'));
+                }
+            }
+        });
+        const ip = sock.resolve(host);
+        if (!ip) {
+            const self = this;
+            os.setTimeout(() => {
+                self._fireError(new Error('DNS resolution failed for: ' + host));
+                if (self._state !== State.CLOSED)
+                    self._setState(State.CLOSED);
+            }, 0);
+            return;
+        }
+        sock.connect(fd, ip, port);
+    }
+    _sendRaw(buf) {
+        if (!this._sock)
+            return;
+        if (this._ssl) {
+            wolfssl.wolfSSL_write(this._ssl, buf);
+        }
+        else {
+            sock.send(this._sock, buf);
+        }
+    }
+    _sendRawStr(str) {
+        const buf = new ArrayBuffer(str.length);
+        const view = new Uint8Array(buf);
+        for (let i = 0; i < str.length; i++)
+            view[i] = str.charCodeAt(i) & 0xFF;
+        this._sendRaw(buf);
+    }
+    _onData() {
+        while (true) {
+            let data;
+            if (this._ssl) {
+                data = wolfssl.wolfSSL_read(this._ssl, 8192);
+            }
+            else if (this._sock) {
+                data = sock.recv(this._sock, 8192);
+            }
+            else {
+                break;
+            }
+            if (!data || data.byteLength === 0)
+                break;
+            const newBuf = new Uint8Array(this._readBuffer.length + data.byteLength);
+            newBuf.set(this._readBuffer);
+            newBuf.set(new Uint8Array(data), this._readBuffer.length);
+            this._readBuffer = newBuf;
+            while (true) {
+                const frame = tryParseFrame(this._readBuffer);
+                if (!frame)
+                    break;
+                this._readBuffer = this._readBuffer.slice(frame.totalLen);
+                if (frame.opcode === Opcode.TEXT || frame.opcode === Opcode.BINARY) {
+                    const event = new MessageEvent('message', { data: frame.opcode === Opcode.TEXT ? _ab2str(frame.payload.slice(0).buffer) : frame.payload.slice(0).buffer });
+                    this._dispatchEvent('message', event);
+                }
+                else if (frame.opcode === Opcode.PING) {
+                    const pong = createFrame(Opcode.PONG, frame.payload);
+                    this._sendRaw(pong);
+                }
+                else if (frame.opcode === Opcode.PONG) {
+                }
+                else if (frame.opcode === Opcode.CLOSE) {
+                    if (frame.payload.length >= 2) {
+                        this._closeCode = (frame.payload[0] << 8) | frame.payload[1];
+                        this._closeReason = _ab2str(frame.payload.slice(2).buffer);
+                    }
+                    this._cleanup();
+                    this._setState(State.CLOSED);
+                    return;
+                }
+            }
+        }
+    }
+    _setState(state) {
+        if (this._state === state)
+            return;
+        this.readyState = state;
+        this._state = state;
+        if (state === State.OPEN) {
+            this._dispatchEvent('open', new Event('open'));
+        }
+        else if (state === State.CLOSED) {
+            const event = new CloseEvent('close', { code: this._closeCode, reason: this._closeReason, wasClean: true });
+            this._dispatchEvent('close', event);
+        }
+    }
+    _dispatchEvent(type, event) {
+        if (type === 'open' && this.onopen)
+            this.onopen(event);
+        else if (type === 'close' && this.onclose)
+            this.onclose(event);
+        else if (type === 'error' && this.onerror)
+            this.onerror(event);
+        else if (type === 'message' && this.onmessage)
+            this.onmessage(event);
+    }
+    _fireError(err) {
+        this._dispatchEvent('error', new Event('error'));
+    }
+    _cleanup() {
+        if (this._ssl) {
+            wolfssl.wolfSSL_free(this._ssl);
+            this._ssl = null;
+        }
+        if (this._ctx) {
+            wolfssl.wolfSSL_CTX_free(this._ctx);
+            this._ctx = null;
+        }
+        if (this._sock) {
+            sock.closesocket(this._sock);
+            this._sock = null;
+        }
+    }
+}
+// ── Event/MessageEvent/CloseEvent polyfills ──
+class Event {
+    type;
+    constructor(type, _init) { this.type = type; }
+}
+class MessageEvent {
+    type;
+    data;
+    constructor(type, init) {
+        this.type = type;
+        this.data = init.data;
+    }
+}
+class CloseEvent {
+    type;
+    code;
+    reason;
+    wasClean;
+    constructor(type, init) {
+        this.type = type;
+        this.code = init.code || 0;
+        this.reason = init.reason || '';
+        this.wasClean = init.wasClean || false;
+    }
+}
+// ── Utility ──
+function _ab2str(buf) {
+    const view = new Uint8Array(buf);
+    let str = '';
+    for (let i = 0; i < view.length; i++)
+        str += String.fromCharCode(view[i]);
+    return str;
+}
+// ── Register globals ──
+globalThis.WebSocket = WebSocket;