@pasko70/pibo 3.4.4 → 3.5.1

package/dist/web/channel.js

@@ -191,15 +191,31 @@ function createGatewayRuntimeStatuses(channelContext) {
         }
     });
 }
-function createGatewayStatusResponse(channelContext, options, generation) {
+async function createGatewayStatusResponse(channelContext, options, generation) {
     const mode = gatewayMode(options);
+    const appStatuses = {};
+    for (const app of channelContext.getWebApps()) {
+        if (!app.gatewayStatus)
+            continue;
+        try {
+            Object.assign(appStatuses, await app.gatewayStatus());
+        }
+        catch (error) {
+            appStatuses[`${app.name}Status`] = { status: "ambiguous", error: error instanceof Error ? error.message : "Status unavailable" };
+        }
+    }
+    const durable = appStatuses.durableMessageQueue;
     return responseJson({
-        status: "ok",
+        status: durable?.status === "degraded" || durable?.status === "ambiguous" ? "degraded" : "ok",
         mode,
         generation,
-        health: { status: "ok", mode },
+        health: { status: durable?.status === "degraded" || durable?.status === "ambiguous" ? "degraded" : "ok", mode },
+        runtimeQueue: { layer: "runtime-session", statuses: createGatewayRuntimeStatuses(channelContext) },
         runtimeStatuses: createGatewayRuntimeStatuses(channelContext),
+        ...(channelContext.getRuntimeCapacityStatus ? { runtimeCapacity: channelContext.getRuntimeCapacityStatus() } : {}),
+        ...(channelContext.getRunJobReliabilityStatus ? { reliability: channelContext.getRunJobReliabilityStatus() } : {}),
         activeRuns: collectActiveRuns(channelContext),
+        ...appStatuses,
     });
 }
 function createCanonicalRedirect(request, canonicalBaseURL) {
@@ -217,6 +233,68 @@ function createCanonicalRedirect(request, canonicalBaseURL) {
 function isEventStreamResponse(response) {
     return response.headers.get("content-type")?.toLowerCase().startsWith("text/event-stream") === true;
 }
+function responseCanStart(response) {
+    return !response.destroyed && !response.writableEnded && !response.writableFinished && !response.headersSent;
+}
+function responseState(response) {
+    return [
+        `destroyed=${response.destroyed}`,
+        `writableEnded=${response.writableEnded}`,
+        `writableFinished=${response.writableFinished}`,
+        `headersSent=${response.headersSent}`,
+    ].join(",");
+}
+function requestPath(request) {
+    return (request.url ?? "/").split(/[?#]/, 1)[0].slice(0, 256).replace(/[\r\n]/g, "_");
+}
+function errorIdentity(error) {
+    try {
+        if (!(error instanceof Error))
+            return typeof error;
+        const rawName = typeof error.name === "string" ? error.name : "Error";
+        const name = rawName.replace(/[^A-Za-z0-9_.-]/g, "").slice(0, 64) || "Error";
+        const code = "code" in error && typeof error.code === "string" ? error.code.replace(/[^A-Za-z0-9_-]/g, "").slice(0, 64) : undefined;
+        return code ? `${name}:${code}` : name;
+    }
+    catch {
+        return "Error";
+    }
+}
+function logHttpBoundaryFailure(phase, request, error, response) {
+    try {
+        const method = (request.method ?? "UNKNOWN").replace(/[^A-Z]/gi, "").slice(0, 16) || "UNKNOWN";
+        const state = response ? ` response={${responseState(response)}}` : "";
+        console.error(`[web-host] contained ${phase} failure method=${method} path=${requestPath(request)} error=${errorIdentity(error)}${state}`);
+    }
+    catch {
+        // Diagnostics are best-effort and must never reopen the request rejection path.
+    }
+}
+function terminateResponse(response, error) {
+    if (response.destroyed || response.writableEnded || response.writableFinished)
+        return;
+    try {
+        response.destroy(error instanceof Error ? error : undefined);
+    }
+    catch {
+        // A broken response implementation must not escape the request boundary.
+    }
+}
+function endUpgradeSocket(socket, statusLine) {
+    if (socket.destroyed)
+        return;
+    try {
+        socket.end(statusLine);
+    }
+    catch {
+        try {
+            socket.destroy();
+        }
+        catch {
+            // A broken socket implementation must not escape the upgrade boundary.
+        }
+    }
+}
 async function waitForServerClose(closePromise, timeoutMs) {
     return await new Promise((resolve, reject) => {
         let settled = false;
@@ -322,7 +400,7 @@ export function createWebHostChannel(options = {}) {
                 return;
             }
             if (url.pathname === "/gateway/status") {
-                await sendResponse(nodeResponse, createGatewayStatusResponse(requireContext(), options, generation));
+                await sendResponse(nodeResponse, await createGatewayStatusResponse(requireContext(), options, generation));
                 return;
             }
             if (url.pathname.startsWith("/api/auth/")) {
@@ -359,8 +437,18 @@ export function createWebHostChannel(options = {}) {
         }
         catch (error) {
             const status = error instanceof PiboAuthError || error instanceof PiboWebHttpError ? error.statusCode : 500;
-            if (!nodeResponse.destroyed) {
-                await sendResponse(nodeResponse, responseJson({ error: error instanceof Error ? error.message : String(error) }, { status }));
+            logHttpBoundaryFailure("request", nodeRequest, error, nodeResponse);
+            if (responseCanStart(nodeResponse)) {
+                try {
+                    await sendResponse(nodeResponse, responseJson({ error: error instanceof Error ? error.message : String(error) }, { status }));
+                }
+                catch (responseError) {
+                    logHttpBoundaryFailure("error-response", nodeRequest, responseError, nodeResponse);
+                    terminateResponse(nodeResponse, responseError);
+                }
+            }
+            else {
+                terminateResponse(nodeResponse, error);
             }
         }
         finally {
@@ -383,10 +471,9 @@ export function createWebHostChannel(options = {}) {
             await app.handleUpgrade(nodeRequest, socket, head, createAppContext(ctx), requestURL);
         }
         catch (error) {
-            if (!socket.destroyed) {
-                const unauthorized = error instanceof PiboAuthError || error instanceof PiboWebHttpError;
-                socket.end(`HTTP/1.1 ${unauthorized ? 401 : 502} ${unauthorized ? "Unauthorized" : "Bad Gateway"}\r\nConnection: close\r\n\r\n`);
-            }
+            logHttpBoundaryFailure("upgrade", nodeRequest, error);
+            const unauthorized = error instanceof PiboAuthError || error instanceof PiboWebHttpError;
+            endUpgradeSocket(socket, `HTTP/1.1 ${unauthorized ? 401 : 502} ${unauthorized ? "Unauthorized" : "Bad Gateway"}\r\nConnection: close\r\n\r\n`);
         }
     };
     return {
@@ -401,11 +488,29 @@ export function createWebHostChannel(options = {}) {
                 return;
             shuttingDown = false;
             context = channelContext;
+            for (const app of channelContext.getWebApps())
+                await app.initialize?.(createAppContext(channelContext));
             server = createServer((request, response) => {
-                void handleRequest(request, response);
+                void handleRequest(request, response).catch((error) => {
+                    try {
+                        logHttpBoundaryFailure("request-terminal", request, error, response);
+                        terminateResponse(response, error);
+                    }
+                    catch {
+                        // The terminal request boundary itself is intentionally nonthrowing.
+                    }
+                });
             });
             server.on("upgrade", (request, socket, head) => {
-                void handleUpgrade(request, socket, head);
+                void handleUpgrade(request, socket, head).catch((error) => {
+                    try {
+                        logHttpBoundaryFailure("upgrade-terminal", request, error);
+                        endUpgradeSocket(socket);
+                    }
+                    catch {
+                        // The terminal upgrade boundary itself is intentionally nonthrowing.
+                    }
+                });
             });
             server.on("connection", (socket) => {
                 sockets.add(socket);

package/dist/web/http.js

@@ -78,61 +78,136 @@ export async function nodeRequestToWebRequest(request, baseURL, signal) {
     });
 }
 export async function sendWebResponse(response, webResponse, options = {}) {
+    assertResponseCanStart(response);
     const headers = responseHeaders(webResponse);
     const compressEncoding = preferredResponseEncoding(response.req?.headers["accept-encoding"], webResponse);
-    if (compressEncoding && webResponse.body) {
-        const body = await readResponseBody(webResponse);
-        if (body.length >= MIN_COMPRESS_RESPONSE_BYTES && body.length <= MAX_SYNC_GZIP_RESPONSE_BYTES) {
-            const compressionStartedAt = performance.now();
-            const compressed = gzipSync(body, { level: 1 });
-            appendServerTimingHeader(headers, `response_compress;dur=${(performance.now() - compressionStartedAt).toFixed(1)}`);
-            headers["content-encoding"] = compressEncoding;
-            headers["content-length"] = String(compressed.length);
-            headers.vary = appendVary(headers.vary, "accept-encoding");
+    let reader = webResponse.body?.getReader();
+    let wroteHeaders = false;
+    let clientClosed = false;
+    const cancelReader = () => {
+        if (reader)
+            void reader.cancel().catch(() => undefined);
+    };
+    const close = () => {
+        clientClosed = true;
+        cancelReader();
+    };
+    const abort = () => {
+        cancelReader();
+        try {
+            if (!response.destroyed && !response.writableEnded)
+                response.end();
+        }
+        catch {
+            tryDestroyResponse(response);
+        }
+        try {
+            response.socket?.end();
+        }
+        catch {
+            tryDestroyResponse(response);
+        }
+    };
+    if (reader) {
+        response.once("close", close);
+        options.signal?.addEventListener("abort", abort, { once: true });
+        if (options.signal?.aborted)
+            abort();
+    }
+    try {
+        if (compressEncoding && reader) {
+            const body = await readResponseBody(reader);
+            if (clientClosed || options.signal?.aborted || response.destroyed || response.writableEnded || response.writableFinished)
+                return;
+            assertResponseCanStart(response);
+            if (body.length >= MIN_COMPRESS_RESPONSE_BYTES && body.length <= MAX_SYNC_GZIP_RESPONSE_BYTES) {
+                const compressionStartedAt = performance.now();
+                const compressed = gzipSync(body, { level: 1 });
+                appendServerTimingHeader(headers, `response_compress;dur=${(performance.now() - compressionStartedAt).toFixed(1)}`);
+                headers["content-encoding"] = compressEncoding;
+                headers["content-length"] = String(compressed.length);
+                headers.vary = appendVary(headers.vary, "accept-encoding");
+                response.writeHead(webResponse.status, headers);
+                wroteHeaders = true;
+                response.end(compressed);
+                return;
+            }
+            if (body.length > MAX_SYNC_GZIP_RESPONSE_BYTES) {
+                headers["x-pibo-compression-skipped"] = "sync-gzip-size-limit";
+            }
             response.writeHead(webResponse.status, headers);
-            response.end(compressed);
+            wroteHeaders = true;
+            response.end(body);
             return;
         }
-        if (body.length > MAX_SYNC_GZIP_RESPONSE_BYTES) {
-            headers["x-pibo-compression-skipped"] = "sync-gzip-size-limit";
-        }
         response.writeHead(webResponse.status, headers);
-        response.end(body);
-        return;
-    }
-    response.writeHead(webResponse.status, headers);
-    if (!webResponse.body) {
-        response.end();
-        return;
-    }
-    const reader = webResponse.body.getReader();
-    const cancel = () => {
-        void reader.cancel();
-    };
-    const abort = () => {
-        const socket = response.socket;
-        void reader.cancel();
-        if (!response.writableEnded)
+        wroteHeaders = true;
+        if (!reader) {
             response.end();
-        socket?.end();
-    };
-    response.once("close", cancel);
-    options.signal?.addEventListener("abort", abort, { once: true });
-    if (options.signal?.aborted)
-        abort();
-    try {
+            return;
+        }
         while (true) {
             const { done, value } = await reader.read();
             if (done)
                 break;
-            response.write(Buffer.from(value));
+            const bytes = Buffer.from(value.buffer, value.byteOffset, value.byteLength);
+            for (let offset = 0; offset < bytes.length; offset += 64 * 1024) {
+                if (response.destroyed || response.writableEnded || response.writableFinished) {
+                    cancelReader();
+                    return;
+                }
+                if (!response.write(bytes.subarray(offset, offset + 64 * 1024))) {
+                    const drained = await waitForResponseDrain(response, (webResponse.headers.get("content-type") ?? "").startsWith("text/event-stream") ? 5000 : undefined, options.signal);
+                    if (!drained) {
+                        cancelReader();
+                        tryDestroyResponse(response);
+                        return;
+                    }
+                }
+            }
         }
-        if (!response.writableEnded)
+        if (!response.destroyed && !response.writableEnded && !response.writableFinished)
             response.end();
     }
+    catch (error) {
+        cancelReader();
+        if (clientClosed || response.destroyed || response.writableEnded || response.writableFinished)
+            return;
+        if (wroteHeaders || response.headersSent)
+            tryDestroyResponse(response, error);
+        throw error;
+    }
     finally {
-        response.off("close", cancel);
+        response.off("close", close);
         options.signal?.removeEventListener("abort", abort);
+        if (reader) {
+            try {
+                reader.releaseLock();
+            }
+            catch {
+                // Cancellation/read settlement owns the lock until the pending read resolves.
+            }
+        }
+    }
+}
+function assertResponseCanStart(response) {
+    if (response.destroyed)
+        throw new Error("HTTP response is destroyed");
+    if (response.writableEnded)
+        throw new Error("HTTP response has ended");
+    if (response.writableFinished)
+        throw new Error("HTTP response has finished");
+    if (response.headersSent)
+        throw new Error("HTTP response headers were already sent");
+}
+function tryDestroyResponse(response, error) {
+    if (response.destroyed)
+        return;
+    try {
+        response.destroy(error instanceof Error ? error : undefined);
+    }
+    catch {
+        // The request boundary is best-effort once the response implementation itself fails.
     }
 }
 function appendServerTimingHeader(headers, value) {
@@ -185,9 +260,8 @@ function responseCanBeCompressed(webResponse) {
     const contentType = webResponse.headers.get("content-type") ?? "";
     return /^application\/json\b/.test(contentType);
 }
-async function readResponseBody(webResponse) {
+async function readResponseBody(reader) {
     const chunks = [];
-    const reader = webResponse.body.getReader();
     while (true) {
         const { done, value } = await reader.read();
         if (done)
@@ -206,3 +280,23 @@ function appendVary(existing, value) {
 function appendServerTiming(existing, value) {
     return existing ? `${existing}, ${value}` : value;
 }
+/** Honor socket pressure before pulling another application frame. */
+function waitForResponseDrain(response, maximumAgeMs, signal) {
+    if (response.destroyed || response.writableEnded || signal?.aborted)
+        return Promise.resolve(false);
+    return new Promise(resolve => {
+        let timer;
+        const finish = (ready) => { if (timer)
+            clearTimeout(timer); response.off("drain", drain); response.off("close", close); response.off("error", close); signal?.removeEventListener("abort", close); resolve(ready); };
+        const drain = () => finish(true);
+        const close = () => finish(false);
+        response.once("drain", drain);
+        response.once("close", close);
+        response.once("error", close);
+        signal?.addEventListener("abort", close, { once: true });
+        if (maximumAgeMs !== undefined) {
+            timer = setTimeout(close, maximumAgeMs);
+            timer.unref();
+        }
+    });
+}

package/npm-shrinkwrap.json

@@ -1,12 +1,12 @@
 {
   "name": "@pasko70/pibo",
-  "version": "3.4.4",
+  "version": "3.5.1",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "@pasko70/pibo",
-      "version": "3.4.4",
+      "version": "3.5.1",
       "workspaces": [
         "packages/workflows"
       ],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pasko70/pibo",
-  "version": "3.4.4",
+  "version": "3.5.1",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",