quickwin 1.3.0 → 2.0.0

package/lib/http-common.js

@@ -193,7 +193,8 @@ export class RequestImpl {
     credentials = 'same-origin';
     referrer = 'about:client';
     referrerPolicy = '';
-    signal = null;
+    signal;
+    rejectUnauthorized;
     destination = '';
     get body() { return this._body; }
     get bodyUsed() {
@@ -214,6 +215,9 @@ export class RequestImpl {
             this.redirect = init.redirect || input.redirect;
             this.timeout = init.timeout || input.timeout;
             this.maxRedirects = init.maxRedirects || input.maxRedirects;
+            this.rejectUnauthorized = init.rejectUnauthorized === undefined
+                ? input.rejectUnauthorized
+                : init.rejectUnauthorized;
         }
         else {
             this.url = input;
@@ -223,7 +227,11 @@ export class RequestImpl {
             this.redirect = init.redirect || 'follow';
             this.timeout = init.timeout || 30000;
             this.maxRedirects = init.maxRedirects || 5;
+            this.rejectUnauthorized = init.rejectUnauthorized ?? true;
         }
+        this.signal = init.signal !== undefined
+            ? init.signal
+            : (input instanceof RequestImpl ? input.signal : null);
     }
     async arrayBuffer() {
         if (!this.body)
@@ -259,6 +267,7 @@ export class RequestImpl {
                 redirect: this.redirect,
                 timeout: this.timeout,
                 maxRedirects: this.maxRedirects,
+                signal: this.signal,
             });
             return req;
         }
@@ -268,6 +277,7 @@ export class RequestImpl {
             redirect: this.redirect,
             timeout: this.timeout,
             maxRedirects: this.maxRedirects,
+            signal: this.signal,
         });
     }
 }
@@ -282,8 +292,12 @@ export class ResponseImpl {
     _url = '';
     _body;
     _bodyConsumed = false;
+    _trailers;
     get body() { return this._body; }
     get bodyUsed() { return this._bodyConsumed || this._body.locked; }
+    /** Trailing headers to emit after a chunked body (Promise resolves to
+     *  a HeadersInit), when a `Trailer` declaration header is present. */
+    get trailers() { return this._trailers; }
     get headers() { return this._headers; }
     get redirected() { return this._redirected; }
     get type() { return this._type; }
@@ -295,10 +309,34 @@ export class ResponseImpl {
         this.status = status;
         this.statusText = statusText;
         this._headers = headers;
+        this._trailers = init?.trailers;
         this.ok = status >= 200 && status < 300;
-        this._body = body != null ? _toReadableStream(body) : new ReadableStream({
-            start(ctrl) { ctrl.close(); }
-        });
+        if (body instanceof ReadableStream) {
+            this._body = body;
+        }
+        else {
+            let bytes;
+            if (body == null) {
+                bytes = new Uint8Array(0);
+            }
+            else if (typeof body === 'string') {
+                bytes = new TextEncoder().encode(body);
+            }
+            else if (body instanceof ArrayBuffer) {
+                bytes = new Uint8Array(body);
+            }
+            else {
+                bytes = new Uint8Array(body.buffer, body.byteOffset, body.byteLength);
+            }
+            if (!headers.has('content-length'))
+                headers.set('Content-Length', String(bytes.byteLength));
+            this._body = new ReadableStream({
+                start(ctrl) {
+                    ctrl.enqueue(bytes);
+                    ctrl.close();
+                }
+            });
+        }
     }
     async text() {
         if (this.bodyUsed)
@@ -328,7 +366,7 @@ export class ResponseImpl {
             throw new TypeError('Body already used');
         const [branch1, branch2] = this._body.tee();
         this._body = branch1;
-        return new ResponseImpl(branch2, { status: this.status, statusText: this.statusText, headers: this._headers });
+        return new ResponseImpl(branch2, { status: this.status, statusText: this.statusText, headers: this._headers, trailers: this._trailers });
     }
     _applyDecompressedBody(stream, _body, newHeaders) {
         this._bodyConsumed = false;

package/lib/http-common.ts

@@ -188,7 +188,8 @@ export class RequestImpl {
     readonly credentials: string = 'same-origin'
     readonly referrer: string = 'about:client'
     readonly referrerPolicy: string = ''
-    readonly signal: AbortSignal | null = null
+    readonly signal: AbortSignal | null
+    readonly rejectUnauthorized: boolean
     readonly destination: string = ''
 
     get body(): ReadableStream<Uint8Array> | null { return this._body }
@@ -211,6 +212,9 @@ export class RequestImpl {
             this.redirect = init.redirect || input.redirect
             this.timeout = init.timeout || input.timeout
             this.maxRedirects = init.maxRedirects || input.maxRedirects
+            this.rejectUnauthorized = init.rejectUnauthorized === undefined
+                ? input.rejectUnauthorized
+                : init.rejectUnauthorized
         } else {
             this.url = input
             this.method = init.method || 'GET'
@@ -219,7 +223,11 @@ export class RequestImpl {
             this.redirect = init.redirect || 'follow'
             this.timeout = init.timeout || 30000
             this.maxRedirects = init.maxRedirects || 5
+            this.rejectUnauthorized = init.rejectUnauthorized ?? true
         }
+        this.signal = init.signal !== undefined
+            ? init.signal
+            : (input instanceof RequestImpl ? input.signal : null)
     }
 
     async arrayBuffer(): Promise<ArrayBuffer> {
@@ -254,6 +262,7 @@ export class RequestImpl {
                 redirect: this.redirect,
                 timeout: this.timeout,
                 maxRedirects: this.maxRedirects,
+                signal: this.signal,
             })
             return req
         }
@@ -263,6 +272,7 @@ export class RequestImpl {
             redirect: this.redirect,
             timeout: this.timeout,
             maxRedirects: this.maxRedirects,
+            signal: this.signal,
         })
     }
 }
@@ -280,9 +290,13 @@ export class ResponseImpl {
     _url: string = ''
     private _body: ReadableStream<Uint8Array>
     private _bodyConsumed: boolean = false
+    private _trailers: Promise<HeadersInit> | undefined
 
     get body(): ReadableStream<Uint8Array> { return this._body }
     get bodyUsed(): boolean { return this._bodyConsumed || this._body.locked }
+    /** Trailing headers to emit after a chunked body (Promise resolves to
+     *  a HeadersInit), when a `Trailer` declaration header is present. */
+    get trailers(): Promise<HeadersInit> | undefined { return this._trailers }
     get headers(): HeadersImpl { return this._headers }
     get redirected(): boolean { return this._redirected }
     get type(): ResponseType { return this._type }
@@ -295,10 +309,29 @@ export class ResponseImpl {
         this.status = status
         this.statusText = statusText
         this._headers = headers
+        this._trailers = init?.trailers
         this.ok = status >= 200 && status < 300
-        this._body = body != null ? _toReadableStream(body) : new ReadableStream<Uint8Array>({
-            start(ctrl) { ctrl.close() }
-        })
+        if (body instanceof ReadableStream) {
+            this._body = body
+        } else {
+            let bytes: Uint8Array
+            if (body == null) {
+                bytes = new Uint8Array(0)
+            } else if (typeof body === 'string') {
+                bytes = new TextEncoder().encode(body)
+            } else if (body instanceof ArrayBuffer) {
+                bytes = new Uint8Array(body)
+            } else {
+                bytes = new Uint8Array(body.buffer, body.byteOffset, body.byteLength)
+            }
+            if (!headers.has('content-length')) headers.set('Content-Length', String(bytes.byteLength))
+            this._body = new ReadableStream<Uint8Array>({
+                start(ctrl) {
+                    ctrl.enqueue(bytes)
+                    ctrl.close()
+                }
+            })
+        }
     }
 
     async text(): Promise<string> {
@@ -329,7 +362,7 @@ export class ResponseImpl {
         if (this.bodyUsed) throw new TypeError('Body already used')
         const [branch1, branch2] = this._body.tee()
         this._body = branch1
-        return new ResponseImpl(branch2, { status: this.status, statusText: this.statusText, headers: this._headers })
+        return new ResponseImpl(branch2, { status: this.status, statusText: this.statusText, headers: this._headers, trailers: this._trailers })
     }
 
     _applyDecompressedBody(stream: ReadableStream<Uint8Array>, _body: ArrayBuffer, newHeaders: HeadersImpl): void {
@@ -353,7 +386,9 @@ declare global {
     interface AbortSignal {
         readonly aborted: boolean;
         readonly reason: unknown;
-        onabort: ((event: Event) => void) | null;
+        onabort: ((event: { type: 'abort'; target: unknown }) => void) | null;
+        addEventListener(type: 'abort', listener: (e: { type: 'abort'; target: unknown }) => void): void;
+        removeEventListener(type: 'abort', listener: (e: { type: 'abort'; target: unknown }) => void): void;
         throwIfAborted(): void;
     }
 
@@ -373,12 +408,19 @@ declare global {
         window?: null;
         timeout?: number;
         maxRedirects?: number;
+        /** Non-standard: when false, TLS certificate verification is skipped
+         *  (mirrors Node's https.request rejectUnauthorized option). */
+        rejectUnauthorized?: boolean;
     }
 
     interface ResponseInit {
         status?: number;
         statusText?: string;
         headers?: HeadersInit;
+        /** Non-standard: trailing headers, resolved after the body streams.
+         *  http-server emits them (Node addTrailers semantics) when a `Trailer`
+         *  declaration header is present and the body is chunk-framed. */
+        trailers?: Promise<HeadersInit>;
     }
 
     interface Headers extends HeadersImpl {}

package/lib/http-server.js

@@ -1,6 +1,7 @@
 import './polyfill.js';
 import * as sock from 'sock';
 import { HeadersImpl, RequestImpl, ResponseImpl, _readStream } from './http-common.js';
+import { AbortController } from './abort.js';
 const STATUS_TEXT = {
     100: 'Continue', 101: 'Switching Protocols',
     200: 'OK', 201: 'Created', 202: 'Accepted', 204: 'No Content',
@@ -33,6 +34,22 @@ function findCrLfCrLf(buf) {
     }
     return -1;
 }
+/** Flatten a `HeadersInit` into `[name, value]` pairs, preserving the
+ *  casing the caller provided (Node `addTrailers` semantics). */
+function headersInitToPairs(init) {
+    if (init instanceof HeadersImpl) {
+        const out = [];
+        for (const [name, value] of init)
+            out.push([name, value]);
+        return out;
+    }
+    if (Array.isArray(init))
+        return init.map(([name, value]) => [name, String(value)]);
+    const out = [];
+    for (const name of Object.keys(init))
+        out.push([name, String(init[name])]);
+    return out;
+}
 /** Decode a chunked-transfer body starting at `start`. Returns the decoded
  *  data and the offset just past the terminating CRLF, or null if the buffer
  *  does not yet contain the complete chunked body. */
@@ -176,10 +193,12 @@ export class HttpServer {
                 pending: null,
                 current: null,
                 outQueue: null,
+                resumeRead: null,
                 closed: false,
                 closeAfterFlush: false,
                 keepAlive: true,
                 owner: this,
+                ac: null,
             };
             this.conns.set(c.sock, c);
             sock.set_on_event(c.sock, (event) => this.onConnEvent(c, event));
@@ -194,8 +213,8 @@ export class HttpServer {
             flushQueue(c);
         if (event.lNetworkEvents & 32 /* sock.FdEvent.FD_CLOSE */) {
             onRead(c);
-            if (!c.current && !c.pending)
-                closeConn(c);
+            abortConn(c);
+            closeConn(c);
         }
     }
 }
@@ -215,24 +234,28 @@ function onRead(c) {
     if (!c.closed)
         tryProcess(c);
 }
+/** Send `data`, or queue it when the kernel send buffer is full.
+ *  Returns true when the data was fully handed to the kernel, or false
+ *  when it has been buffered (or partially handed over) and the caller
+ *  should back off until `flushQueue` drains and calls `c.resumeRead`. */
 function queueSend(c, data) {
     if (c.closed || data.length === 0)
-        return;
+        return true;
     if (c.outQueue && c.outQueue.length > 0) {
         c.outQueue = concatU8([c.outQueue, data]);
-        return;
+        return false;
     }
     const ret = sock.send(c.sock, toArrayBuffer(data));
     if (ret < 0) {
-        c.outQueue = data;
-        return;
+        abortConn(c);
+        closeConn(c);
+        return true;
     }
     if (ret < data.length) {
         c.outQueue = data.subarray(ret);
-        return;
+        return false;
     }
-    if (c.closeAfterFlush)
-        closeConn(c);
+    return true;
 }
 function flushQueue(c) {
     if (c.closed)
@@ -240,12 +263,17 @@ function flushQueue(c) {
     if (!c.outQueue || c.outQueue.length === 0) {
         if (c.closeAfterFlush)
             closeConn(c);
+        else
+            resumeReader(c);
         return;
     }
     const q = c.outQueue;
     const ret = sock.send(c.sock, toArrayBuffer(q));
-    if (ret < 0)
+    if (ret < 0) {
+        abortConn(c);
+        closeConn(c);
         return;
+    }
     if (ret < q.length) {
         c.outQueue = q.subarray(ret);
         return;
@@ -253,15 +281,101 @@ function flushQueue(c) {
     c.outQueue = null;
     if (c.closeAfterFlush)
         closeConn(c);
+    else
+        resumeReader(c);
 }
 function closeConn(c) {
     if (c.closed)
         return;
     c.closed = true;
+    resumeReader(c);
     if (c.sock >= 0)
         sock.closesocket(c.sock);
     c.owner.conns.delete(c.sock);
 }
+/** Abort the in-flight request (notifying its handler via `req.signal`).
+ *  Safe to call when idle or already aborted: the controller is cleared so
+ *  a fresh request on this connection gets a fresh signal. */
+function abortConn(c) {
+    const ac = c.ac;
+    c.ac = null;
+    if (ac)
+        ac.abort();
+}
+/** Resolve the pending back-pressure awaiter, if any. Called whenever the
+ *  send queue drains or the connection closes. */
+function resumeReader(c) {
+    const r = c.resumeRead;
+    c.resumeRead = null;
+    if (r)
+        r();
+}
+/** Close the connection once a response is fully flushed, when the
+ *  handler or client asked for `Connection: close`. */
+function finishResponse(c) {
+    if (c.closeAfterFlush && !c.outQueue)
+        closeConn(c);
+}
+/** Frame `data` as a single chunked-transfer block: `<hex size>\r\n<data>\r\n`. */
+function encodeChunkFrame(data, enc) {
+    return concatU8([enc.encode(data.byteLength.toString(16) + '\r\n'), data, enc.encode('\r\n')]);
+}
+/** Read `body` one chunk at a time and send it out. When the kernel send
+ *  buffer fills up (`queueSend` returns false) we pause on `c.resumeRead`,
+ *  which `flushQueue` resumes once the socket drains — backpressure. */
+async function writeStreamingBody(c, body, chunked, trailer) {
+    if (c.closed || body == null)
+        return;
+    const reader = body.getReader();
+    const enc = new TextEncoder();
+    try {
+        while (!c.closed) {
+            const { done, value } = await reader.read();
+            if (done)
+                break;
+            if (value && value.byteLength > 0) {
+                const frame = chunked ? encodeChunkFrame(value, enc) : value;
+                if (!queueSend(c, frame)) {
+                    await new Promise((resolve) => { c.resumeRead = resolve; });
+                }
+            }
+        }
+        if (c.closed) {
+            // 客户端断开（FD_CLOSE / send 失败）：取消响应体，让 producer 感知
+            //（exec_server 借此 kill 子进程），而不是干等它自然结束。
+            try {
+                await reader.cancel();
+            }
+            catch (e) {
+                console.error('[http-server] body cancel error:', e);
+            }
+            return;
+        }
+        if (chunked) {
+            let terminator = '0\r\n\r\n';
+            if (trailer) {
+                try {
+                    const pairs = headersInitToPairs(await trailer);
+                    if (pairs.length > 0) {
+                        let s = '0\r\n';
+                        for (const [name, value] of pairs)
+                            s += name + ': ' + value + '\r\n';
+                        s += '\r\n';
+                        terminator = s;
+                    }
+                }
+                catch (e) {
+                    console.error('[http-server] trailers promise rejected:', e);
+                }
+            }
+            queueSend(c, enc.encode(terminator));
+        }
+        finishResponse(c);
+    }
+    finally {
+        reader.releaseLock();
+    }
+}
 // ── Request state machine ──
 function whole(c) {
     return concatU8(c.parts);
@@ -345,11 +459,14 @@ function dispatchRequest(c, parsed, body, end) {
     }
     const isAbsolute = parsed.target.startsWith('http://') || parsed.target.startsWith('https://');
     const url = isAbsolute ? parsed.target : 'http://' + host + parsed.target;
+    const ac = new AbortController();
     const req = new RequestImpl(url, {
         method: parsed.method,
         headers: new HeadersImpl(parsed.headers),
         body: body.length > 0 ? body : undefined,
+        signal: ac.signal,
     });
+    c.ac = ac;
     c.current = { req };
     trimParts(c, whole(c), end);
     void handleRequest(c);
@@ -377,40 +494,81 @@ async function handleRequest(c) {
     }
     if (c.closed)
         return;
-    await sendResponse(c, req.method, res);
+    try {
+        await sendResponse(c, req.method, res);
+    }
+    catch (e) {
+        console.error('[http-server] response send error:', e);
+        if (!c.closed)
+            closeConn(c);
+        return;
+    }
     if (c.closed)
         return;
     c.current = null;
     if (!c.closeAfterFlush)
         tryProcess(c);
 }
+function buildHead(status, statusText, headers) {
+    let head = 'HTTP/1.1 ' + status + ' ' + statusText + '\r\n';
+    for (const [name, value] of headers)
+        head += name + ': ' + value + '\r\n';
+    head += '\r\n';
+    return new TextEncoder().encode(head);
+}
 async function sendResponse(c, method, res) {
     const status = res.status;
     const statusText = res.statusText || STATUS_TEXT[status] || 'OK';
     const headers = new HeadersImpl(res.headers);
-    let body;
-    try {
-        body = await _readStream(res.body);
-    }
-    catch {
-        body = new Uint8Array(0);
-    }
-    if (c.closed)
-        return;
     const headOnly = method === 'HEAD';
     const bodyless = (status >= 100 && status < 200) || status === 204 || status === 304;
-    if (!headers.has('content-length') && !bodyless)
-        headers.set('Content-Length', String(body.length));
     if (!headers.has('connection'))
         headers.set('Connection', c.keepAlive ? 'keep-alive' : 'close');
     const connHdr = (headers.get('connection') || '').toLowerCase();
     if (!c.keepAlive || connHdr === 'close')
         c.closeAfterFlush = true;
-    let head = 'HTTP/1.1 ' + status + ' ' + statusText + '\r\n';
-    for (const [name, value] of headers)
-        head += name + ': ' + value + '\r\n';
-    head += '\r\n';
-    const headBytes = new TextEncoder().encode(head);
-    const payload = headOnly || body.length === 0 ? headBytes : concatU8([headBytes, body]);
-    queueSend(c, payload);
+    if (bodyless) {
+        headers.delete('Transfer-Encoding');
+        headers.delete('Content-Length');
+        headers.delete('Trailer');
+        queueSend(c, buildHead(status, statusText, headers));
+        finishResponse(c);
+        return;
+    }
+    if (headOnly) {
+        headers.delete('Transfer-Encoding');
+        headers.delete('Trailer');
+        if (!headers.has('content-length')) {
+            try {
+                const full = await _readStream(res.body);
+                headers.set('Content-Length', String(full.length));
+            }
+            catch { /* leave length unspecified */ }
+        }
+        if (c.closed)
+            return;
+        queueSend(c, buildHead(status, statusText, headers));
+        finishResponse(c);
+        return;
+    }
+    // Body is streamed out chunk by chunk. A declared Content-Length sends
+    // the bytes as-is; otherwise we use chunked framing.
+    const chunked = (headers.get('transfer-encoding') || '').toLowerCase() === 'chunked' ||
+        !headers.has('content-length');
+    // Trailing headers are only emitted when the body is chunk-framed and a
+    // `Trailer` declaration header is present (Node addTrailers semantics).
+    const trailerDeclared = (headers.get('trailer') || '').trim().length > 0;
+    if (chunked) {
+        headers.delete('Content-Length');
+        if (!headers.has('transfer-encoding'))
+            headers.set('Transfer-Encoding', 'chunked');
+        if (!trailerDeclared)
+            headers.delete('Trailer');
+    }
+    else {
+        headers.delete('Transfer-Encoding');
+        headers.delete('Trailer');
+    }
+    queueSend(c, buildHead(status, statusText, headers));
+    await writeStreamingBody(c, res.body, chunked, (chunked && trailerDeclared) ? res.trailers : undefined);
 }