@pasko70/pibo 1.13.0 → 1.14.0

package/dist/web/channel.js

@@ -6,6 +6,7 @@ import { PiboWebHttpError, nodeRequestToWebRequest, responseHtml, responseJson,
 export const DEFAULT_WEB_CHANNEL_HOST = "127.0.0.1";
 export const DEFAULT_WEB_CHANNEL_PORT = 4788;
 export const WEB_CHANNEL_NAME = "web-host";
+const DEFAULT_SHUTDOWN_DRAIN_TIMEOUT_MS = 5_000;
 /**
  * Internal header that carries the TCP socket peer address from the web host
  * channel to the auth plugin. This is one of three independent safety layers
@@ -168,11 +169,44 @@ function createCanonicalRedirect(request, canonicalBaseURL) {
     }
     return redirect(new URL(`${url.pathname}${url.search}`, canonical.origin).toString());
 }
+function isEventStreamResponse(response) {
+    return response.headers.get("content-type")?.toLowerCase().startsWith("text/event-stream") === true;
+}
+async function waitForServerClose(closePromise, timeoutMs) {
+    return await new Promise((resolve, reject) => {
+        let settled = false;
+        const timeout = setTimeout(() => {
+            settled = true;
+            resolve(false);
+        }, timeoutMs);
+        closePromise.then(() => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            resolve(true);
+        }, (error) => {
+            if (settled)
+                return;
+            settled = true;
+            clearTimeout(timeout);
+            reject(error);
+        });
+    });
+}
 export function createWebHostChannel(options = {}) {
     const host = options.host ?? DEFAULT_WEB_CHANNEL_HOST;
     const port = options.port ?? DEFAULT_WEB_CHANNEL_PORT;
+    const shutdownDrainTimeoutMs = options.shutdownDrainTimeoutMs ?? DEFAULT_SHUTDOWN_DRAIN_TIMEOUT_MS;
+    if (!Number.isFinite(shutdownDrainTimeoutMs) || shutdownDrainTimeoutMs < 0) {
+        throw new Error("Web channel shutdown drain timeout must be a non-negative finite number");
+    }
     let server;
     let context;
+    let stopPromise;
+    let shuttingDown = false;
+    const sockets = new Set();
+    const eventStreamControllers = new Map();
     const requireContext = () => {
         if (!context)
             throw new Error("Web channel is not started");
@@ -185,6 +219,20 @@ export function createWebHostChannel(options = {}) {
         }
         return auth.handleRequest(request);
     };
+    const sendResponse = async (nodeResponse, webResponse) => {
+        const eventStreamController = isEventStreamResponse(webResponse) ? new AbortController() : undefined;
+        if (eventStreamController)
+            eventStreamControllers.set(nodeResponse, eventStreamController);
+        try {
+            await sendWebResponse(nodeResponse, webResponse, { signal: eventStreamController?.signal });
+        }
+        finally {
+            if (eventStreamController)
+                eventStreamControllers.delete(nodeResponse);
+            if (shuttingDown)
+                server?.closeIdleConnections();
+        }
+    };
     const handleRequest = async (nodeRequest, nodeResponse) => {
         try {
             const baseURL = createRequestBaseURL(nodeRequest, host, port);
@@ -198,51 +246,51 @@ export function createWebHostChannel(options = {}) {
             const url = new URL(request.url);
             const canonicalRedirect = createCanonicalRedirect(request, options.canonicalBaseURL);
             if (canonicalRedirect) {
-                await sendWebResponse(nodeResponse, canonicalRedirect);
+                await sendResponse(nodeResponse, canonicalRedirect);
                 return;
             }
             if (url.pathname === "/health") {
-                await sendWebResponse(nodeResponse, responseJson({
+                await sendResponse(nodeResponse, responseJson({
                     status: "ok",
                     mode: process.env.PIBO_FALLBACK_MODE === "1" ? "fallback" : "main",
                 }));
                 return;
             }
             if (url.pathname === "/gateway/status") {
-                await sendWebResponse(nodeResponse, createGatewayStatusResponse(requireContext(), options));
+                await sendResponse(nodeResponse, createGatewayStatusResponse(requireContext(), options));
                 return;
             }
             if (url.pathname.startsWith("/api/auth/")) {
                 const authResponse = stripSocketPeerHeaderFromResponse(await handleAuthRequest(request));
-                await sendWebResponse(nodeResponse, authResponse);
+                await sendResponse(nodeResponse, authResponse);
                 return;
             }
             const ctx = requireContext();
             const simpleApiResponse = await handleSimpleAgentApiRequest(request, ctx);
             if (simpleApiResponse) {
-                await sendWebResponse(nodeResponse, simpleApiResponse);
+                await sendResponse(nodeResponse, simpleApiResponse);
                 return;
             }
             const apps = ctx.getWebApps();
             const app = apps.find((candidate) => matchPrefix(url.pathname, candidate.mountPath) || matchPrefix(url.pathname, candidate.apiPrefix));
             if (app) {
                 const response = await app.handleRequest(request, createAppContext(ctx));
-                await sendWebResponse(nodeResponse, response ?? notFound());
+                await sendResponse(nodeResponse, response ?? notFound());
                 return;
             }
             if (url.pathname === "/" && apps[0]) {
-                await sendWebResponse(nodeResponse, redirect(apps[0].mountPath));
+                await sendResponse(nodeResponse, redirect(apps[0].mountPath));
                 return;
             }
             if (url.pathname === "/") {
-                await sendWebResponse(nodeResponse, responseHtml("<!doctype html><title>Pibo</title><p>No web apps registered.</p>"));
+                await sendResponse(nodeResponse, responseHtml("<!doctype html><title>Pibo</title><p>No web apps registered.</p>"));
                 return;
             }
-            await sendWebResponse(nodeResponse, notFound());
+            await sendResponse(nodeResponse, notFound());
         }
         catch (error) {
             const status = error instanceof PiboAuthError || error instanceof PiboWebHttpError ? error.statusCode : 500;
-            await sendWebResponse(nodeResponse, responseJson({ error: error instanceof Error ? error.message : String(error) }, { status }));
+            await sendResponse(nodeResponse, responseJson({ error: error instanceof Error ? error.message : String(error) }, { status }));
         }
     };
     return {
@@ -251,12 +299,19 @@ export function createWebHostChannel(options = {}) {
         description: "Same-origin HTTP host for pibo web apps and auth routes.",
         auth: { mode: "required" },
         async start(channelContext) {
+            if (stopPromise)
+                await stopPromise;
             if (server)
                 return;
+            shuttingDown = false;
             context = channelContext;
             server = createServer((request, response) => {
                 void handleRequest(request, response);
             });
+            server.on("connection", (socket) => {
+                sockets.add(socket);
+                socket.once("close", () => sockets.delete(socket));
+            });
             await new Promise((resolve, reject) => {
                 server.once("error", reject);
                 server.listen(port, host, () => {
@@ -270,12 +325,46 @@ export function createWebHostChannel(options = {}) {
             }
         },
         async stop() {
-            context = undefined;
-            if (server) {
-                await new Promise((resolve, reject) => {
-                    server.close((error) => (error ? reject(error) : resolve()));
-                });
-                server = undefined;
+            if (stopPromise)
+                return await stopPromise;
+            if (!server) {
+                context = undefined;
+                return;
+            }
+            const closingServer = server;
+            shuttingDown = true;
+            stopPromise = (async () => {
+                try {
+                    const closePromise = new Promise((resolve, reject) => {
+                        closingServer.close((error) => (error ? reject(error) : resolve()));
+                    });
+                    const eventStreamCount = eventStreamControllers.size;
+                    for (const controller of eventStreamControllers.values())
+                        controller.abort();
+                    closingServer.closeIdleConnections();
+                    const drained = await waitForServerClose(closePromise, shutdownDrainTimeoutMs);
+                    if (!drained) {
+                        const connectionCount = sockets.size;
+                        console.warn(`[web-host] graceful shutdown timed out after ${shutdownDrainTimeoutMs} ms; force-closing ${connectionCount} active connection(s)`);
+                        for (const socket of sockets)
+                            socket.destroy();
+                        await closePromise;
+                    }
+                    else if (eventStreamCount > 0) {
+                        console.error(`[web-host] graceful shutdown closed ${eventStreamCount} active event stream(s)`);
+                    }
+                }
+                finally {
+                    server = undefined;
+                    context = undefined;
+                    shuttingDown = false;
+                }
+            })();
+            try {
+                await stopPromise;
+            }
+            finally {
+                stopPromise = undefined;
             }
         },
         getAddress() {

package/dist/web/http.js

@@ -76,7 +76,7 @@ export async function nodeRequestToWebRequest(request, baseURL) {
         body,
     });
 }
-export async function sendWebResponse(response, webResponse) {
+export async function sendWebResponse(response, webResponse, options = {}) {
     const headers = responseHeaders(webResponse);
     const compressEncoding = preferredResponseEncoding(response.req?.headers["accept-encoding"], webResponse);
     if (compressEncoding && webResponse.body) {
@@ -108,7 +108,17 @@ export async function sendWebResponse(response, webResponse) {
     const cancel = () => {
         void reader.cancel();
     };
+    const abort = () => {
+        const socket = response.socket;
+        void reader.cancel();
+        if (!response.writableEnded)
+            response.end();
+        socket?.end();
+    };
     response.once("close", cancel);
+    options.signal?.addEventListener("abort", abort, { once: true });
+    if (options.signal?.aborted)
+        abort();
     try {
         while (true) {
             const { done, value } = await reader.read();
@@ -116,10 +126,12 @@ export async function sendWebResponse(response, webResponse) {
                 break;
             response.write(Buffer.from(value));
         }
-        response.end();
+        if (!response.writableEnded)
+            response.end();
     }
     finally {
         response.off("close", cancel);
+        options.signal?.removeEventListener("abort", abort);
     }
 }
 function appendServerTimingHeader(headers, value) {

package/package.json

@@ -1,10 +1,11 @@
 {
   "name": "@pasko70/pibo",
-  "version": "1.13.0",
+  "version": "1.14.0",
   "type": "module",
-  "imports": {
-    "vscode": "./src/apps/chat-vscode/extension/src/vscode-shim.js"
-  },
+  "workspaces": [
+    "packages/workflows",
+    "src/apps/chat-vscode/extension/vscode-shim"
+  ],
   "description": "Minimal TypeScript wrapper around Pi Coding Agent.",
   "files": [
     "dist",
@@ -39,16 +40,18 @@
     "vscode:webview:build": "vite build --config src/apps/chat-vscode/extension/webview/vite.config.ts",
     "vscode:extension:build": "esbuild src/apps/chat-vscode/extension/src/extension.ts --bundle --platform=node --target=node24 --format=cjs --outfile=src/apps/chat-vscode/dist/extension/extension.cjs --external:vscode --sourcemap=inline",
     "vscode:package": "node scripts/vscode-package.mjs",
+    "workflows:build": "npm run build --workspace @pasko70/pibo-workflows",
+    "workflows:typecheck": "npm run typecheck --workspace @pasko70/pibo-workflows",
     "release": "node scripts/release.mjs",
     "release:github": "node scripts/create-github-release.mjs",
-    "build": "tsc -p tsconfig.json && npm run web-ui:build && npm run vscode:webview:build && node scripts/ensure-bin-executable.mjs",
+    "build": "npm run workflows:build && node --max-old-space-size=1200 node_modules/typescript/bin/tsc -p tsconfig.json && npm run web-ui:build && npm run vscode:webview:build && node scripts/ensure-bin-executable.mjs",
     "start": "node dist/bin/pibo.js",
-    "test": "npm run build && node --test test/*.test.mjs test/chat-vscode/*.test.mjs",
+    "test": "npm run build && node scripts/run-test-suite.mjs",
     "check:product-vocab": "node scripts/legacy-product-vocabulary-gate.mjs",
     "validate:ink-web-derived": "node scripts/ink-cli-web-derived-parity-validate.mjs",
     "compute:limited-worker-smoke": "node scripts/compute-limited-worker-smoke.mjs",
     "validate:goal-endurance": "node scripts/goal-endurance-check.mjs",
-    "typecheck": "tsc -p tsconfig.json --noEmit && npm run chat-ui:typecheck && npm run context-files-ui:typecheck && npm run vscode:typecheck",
+    "typecheck": "npm run workflows:typecheck && node --max-old-space-size=1200 node_modules/typescript/bin/tsc -p tsconfig.json --noEmit && npm run chat-ui:typecheck && npm run context-files-ui:typecheck && npm run vscode:typecheck",
     "clean": "node -e \"fs.rmSync('dist', { recursive: true, force: true })\"",
     "prepack": "npm run build"
   },
@@ -92,6 +95,7 @@
     "tsx": "^4.21.0",
     "typescript": "^6.0.3",
     "vite": "^8.0.10",
+    "vscode": "0.0.0-pibo-test-shim",
     "vite-tsconfig-paths": "^5.1.4"
   }
 }