@aion0/bastion 0.1.7

package/dist/proxy/connect.js

@@ -0,0 +1,298 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.getSessionForSocket = getSessionForSocket;
+exports.setupConnectHandler = setupConnectHandler;
+const node_http_1 = require("node:http");
+const node_https_1 = require("node:https");
+const tls = __importStar(require("node:tls"));
+const net = __importStar(require("node:net"));
+const certs_js_1 = require("./certs.js");
+const router_js_1 = require("./router.js");
+const forwarder_js_1 = require("./forwarder.js");
+const logger_js_1 = require("../utils/logger.js");
+const log = (0, logger_js_1.createLogger)('connect');
+// API domains to MITM intercept — only these get decrypted
+// LLM providers + messaging platforms (for OpenClaw integration)
+const INTERCEPT_HOSTS = new Set([
+    // LLM providers
+    'api.anthropic.com',
+    'api.openai.com',
+    'generativelanguage.googleapis.com',
+    'claude.ai',
+    'chatgpt.com', // ChatGPT Web (OpenAI OAuth mode)
+    // Messaging platforms
+    'api.telegram.org',
+    'discord.com',
+    'gateway.discord.gg',
+    'api.slack.com',
+    'slack.com',
+    'graph.facebook.com', // WhatsApp Business API
+    'api.line.me',
+]);
+// Map socket → session ID for session tracking across CONNECT tunnels
+const socketSessionMap = new WeakMap();
+function getSessionForSocket(socket) {
+    return socketSessionMap.get(socket);
+}
+/**
+ * Parse session ID from Proxy-Authorization header.
+ * When wrap.ts sets HTTPS_PROXY=http://<uuid>@host:port, Node.js sends
+ * a Proxy-Authorization: Basic <base64(uuid:)> header in the CONNECT request.
+ */
+function parseSessionFromProxy(req) {
+    const authHeader = req.headers['proxy-authorization'];
+    if (!authHeader)
+        return undefined;
+    const match = authHeader.match(/^Basic\s+(.+)$/i);
+    if (!match)
+        return undefined;
+    try {
+        const decoded = Buffer.from(match[1], 'base64').toString('utf-8');
+        // Format is "username:password" — session UUID is the username
+        const username = decoded.split(':')[0];
+        // Validate it looks like a UUID
+        if (/^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i.test(username)) {
+            return username;
+        }
+    }
+    catch {
+        // Invalid base64
+    }
+    return undefined;
+}
+/**
+ * Attach CONNECT handler to an existing HTTP server.
+ * - API hosts: MITM decrypt → plugin pipeline → forward to real upstream
+ * - All other hosts: plain TCP tunnel (no inspection)
+ */
+function setupConnectHandler(server, config, pluginManager) {
+    const ca = (0, certs_js_1.ensureCA)();
+    server.on('connect', (req, clientSocket, head) => {
+        const [hostname, portStr] = (req.url ?? '').split(':');
+        const port = parseInt(portStr, 10) || 443;
+        // Extract session ID from proxy auth header, or auto-generate for intercepted hosts
+        let sessionId = parseSessionFromProxy(req);
+        const source = sessionId ? 'wrap' : 'auto';
+        if (!sessionId && INTERCEPT_HOSTS.has(hostname)) {
+            sessionId = crypto.randomUUID();
+        }
+        if (sessionId) {
+            socketSessionMap.set(clientSocket, sessionId);
+            log.debug('Session mapped', { sessionId, hostname, source });
+        }
+        if (INTERCEPT_HOSTS.has(hostname)) {
+            log.info('CONNECT', { hostname, port, sessionId, source });
+        }
+        else {
+            log.debug('CONNECT tunnel', { hostname, port });
+        }
+        if (INTERCEPT_HOSTS.has(hostname)) {
+            handleMITM(hostname, port, clientSocket, head, ca, config, pluginManager, sessionId, source);
+        }
+        else {
+            handleTunnel(hostname, port, clientSocket, head);
+        }
+    });
+    log.info('CONNECT handler registered', {
+        interceptHosts: [...INTERCEPT_HOSTS],
+        caCert: (0, certs_js_1.getCACertPath)(),
+    });
+}
+/**
+ * Plain TCP tunnel — no inspection, no modification.
+ * Used for OAuth flows, browser traffic, etc.
+ */
+function handleTunnel(hostname, port, clientSocket, head) {
+    const serverSocket = net.connect(port, hostname, () => {
+        clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
+        if (head.length > 0)
+            serverSocket.write(head);
+        serverSocket.pipe(clientSocket);
+        clientSocket.pipe(serverSocket);
+    });
+    serverSocket.on('error', (err) => {
+        log.error('Tunnel error', { hostname, error: err.message });
+        clientSocket.end();
+    });
+    clientSocket.on('error', () => {
+        serverSocket.end();
+    });
+    clientSocket.on('close', () => {
+        serverSocket.end();
+    });
+}
+/**
+ * MITM interception for API hosts.
+ * 1. Accept TLS from client using host cert signed by our CA
+ * 2. Decrypt the HTTP request
+ * 3. Run through plugin pipeline (DLP, metrics, optimizer)
+ * 4. Forward to real upstream
+ */
+function handleMITM(hostname, port, clientSocket, head, ca, config, pluginManager, sessionId, sessionSource) {
+    const hostCert = (0, certs_js_1.getHostCert)(hostname);
+    // Tell client the tunnel is established
+    clientSocket.write('HTTP/1.1 200 Connection Established\r\n\r\n');
+    // Wrap client socket with TLS (we act as the target server)
+    const tlsSocket = new tls.TLSSocket(clientSocket, {
+        isServer: true,
+        key: hostCert.key,
+        cert: hostCert.cert,
+    });
+    // Create a per-connection HTTP server to parse the decrypted request
+    const handler = createMITMRequestHandler(hostname, config, pluginManager, sessionId, sessionSource);
+    const fakeServer = (0, node_http_1.createServer)(handler);
+    // Inject the TLS socket as a "connection" to the HTTP server
+    fakeServer.emit('connection', tlsSocket);
+    if (head.length > 0) {
+        tlsSocket.unshift(head);
+    }
+    tlsSocket.on('error', (err) => {
+        log.debug('MITM TLS error', { hostname, error: err.message });
+    });
+    clientSocket.on('error', () => {
+        tlsSocket.destroy();
+    });
+    clientSocket.on('close', () => {
+        fakeServer.close();
+    });
+}
+/**
+ * Create a request handler for MITM-intercepted connections.
+ * Knows the target hostname, so non-provider paths are forwarded directly.
+ */
+/**
+ * Create a fallback ProviderConfig for intercepted hosts where no
+ * registered provider prefix matches. Ensures all POST traffic from
+ * MITM'd hosts still flows through the plugin pipeline (DLP, audit).
+ */
+function createFallbackProvider(hostname) {
+    return {
+        name: hostname.replace(/\./g, '-'),
+        baseUrl: `https://${hostname}`,
+        authHeader: '',
+        transformHeaders(headers) {
+            const result = {};
+            for (const [key, value] of Object.entries(headers)) {
+                const lower = key.toLowerCase();
+                if (lower !== 'host' && lower !== 'connection' && lower !== 'transfer-encoding') {
+                    result[key] = value;
+                }
+            }
+            return result;
+        },
+        extractModel() { return hostname; },
+        extractUsage() {
+            return { inputTokens: 0, outputTokens: 0 };
+        },
+    };
+}
+function createMITMRequestHandler(hostname, config, pluginManager, sessionId, sessionSource) {
+    return async (req, res) => {
+        // Redact secrets from logged paths (e.g., Telegram bot tokens)
+        const safePath = (req.url ?? '/').replace(/\/bot[^/]+\//, '/bot****/');
+        log.debug('MITM request', { method: req.method, hostname, path: safePath, sessionId });
+        // Try to match a known provider route
+        const route = (0, router_js_1.resolveRoute)(req);
+        // If scanMethods is configured and non-empty, only scan listed methods
+        const scanMethods = config.server.scanMethods ?? [];
+        const shouldScan = scanMethods.length === 0 || scanMethods.includes(req.method ?? '');
+        if (shouldScan) {
+            const provider = route?.provider ?? createFallbackProvider(hostname);
+            const upstreamUrl = route
+                ? route.upstreamUrl
+                : `https://${hostname}${req.url ?? '/'}`;
+            try {
+                await (0, forwarder_js_1.forwardRequest)(req, res, {
+                    provider,
+                    upstreamUrl,
+                    upstreamTimeout: config.timeouts.upstream,
+                    pluginManager,
+                    sessionId,
+                    sessionSource,
+                });
+            }
+            catch (err) {
+                log.error('MITM forward failed', { error: err.message });
+                if (!res.headersSent) {
+                    (0, router_js_1.sendError)(res, 500, 'Internal gateway error');
+                }
+            }
+        }
+        else {
+            // Method excluded from scanning — forward directly
+            directForward(req, res, hostname, config.timeouts.upstream);
+        }
+    };
+}
+/**
+ * Forward a request directly to a known hostname via HTTPS.
+ * Used for non-API-endpoint requests on API domains (e.g., model listing, health checks).
+ */
+function directForward(req, res, hostname, timeout) {
+    const path = req.url ?? '/';
+    // Copy headers, fix host
+    const headers = { ...req.headers };
+    headers['host'] = hostname;
+    delete headers['connection'];
+    const upstreamReq = (0, node_https_1.request)({
+        hostname,
+        port: 443,
+        path,
+        method: req.method,
+        headers,
+        timeout,
+    }, (upstreamRes) => {
+        log.info('MITM direct response', { hostname, path, status: upstreamRes.statusCode });
+        res.writeHead(upstreamRes.statusCode ?? 502, upstreamRes.headers);
+        upstreamRes.pipe(res);
+    });
+    upstreamReq.on('error', (err) => {
+        log.error('MITM direct forward failed', { hostname, error: err.message });
+        if (!res.headersSent) {
+            res.writeHead(502, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({ error: { message: 'Upstream request failed', type: 'gateway_error' } }));
+        }
+    });
+    upstreamReq.on('timeout', () => {
+        upstreamReq.destroy();
+        if (!res.headersSent) {
+            res.writeHead(504, { 'content-type': 'application/json' });
+            res.end(JSON.stringify({ error: { message: 'Upstream request timed out', type: 'gateway_error' } }));
+        }
+    });
+    req.pipe(upstreamReq);
+}
+//# sourceMappingURL=connect.js.map

package/dist/proxy/connect.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"connect.js","sourceRoot":"","sources":["../../src/proxy/connect.ts"],"names":[],"mappings":"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"}

package/dist/proxy/forwarder.d.ts

@@ -0,0 +1,14 @@
+import type { IncomingMessage, ServerResponse } from 'node:http';
+import type { ProviderConfig } from './providers/index.js';
+import type { PluginManager } from '../plugins/index.js';
+import type { RequestContext } from '../plugins/types.js';
+export interface ForwardOptions {
+    provider: ProviderConfig;
+    upstreamUrl: string;
+    upstreamTimeout: number;
+    pluginManager: PluginManager;
+    sessionId?: string;
+    sessionSource?: string;
+}
+export declare function forwardRequest(req: IncomingMessage, res: ServerResponse, options: ForwardOptions): Promise<RequestContext>;
+//# sourceMappingURL=forwarder.d.ts.map

package/dist/proxy/forwarder.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forwarder.d.ts","sourceRoot":"","sources":["../../src/proxy/forwarder.ts"],"names":[],"mappings":"AAGA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,WAAW,CAAC;AACjE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,sBAAsB,CAAC;AAC3D,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,qBAAqB,CAAC;AACzD,OAAO,KAAK,EAAE,cAAc,EAAqD,MAAM,qBAAqB,CAAC;AAO7G,MAAM,WAAW,cAAc;IAC7B,QAAQ,EAAE,cAAc,CAAC;IACzB,WAAW,EAAE,MAAM,CAAC;IACpB,eAAe,EAAE,MAAM,CAAC;IACxB,aAAa,EAAE,aAAa,CAAC;IAC7B,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,aAAa,CAAC,EAAE,MAAM,CAAC;CACxB;AAmBD,wBAAsB,cAAc,CAClC,GAAG,EAAE,eAAe,EACpB,GAAG,EAAE,cAAc,EACnB,OAAO,EAAE,cAAc,GACtB,OAAO,CAAC,cAAc,CAAC,CAsJzB"}

package/dist/proxy/forwarder.js

@@ -0,0 +1,342 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.forwardRequest = forwardRequest;
+const node_https_1 = require("node:https");
+const node_http_1 = require("node:http");
+const node_crypto_1 = require("node:crypto");
+const streaming_js_1 = require("./streaming.js");
+const streaming_guard_js_1 = require("../tool-guard/streaming-guard.js");
+const logger_js_1 = require("../utils/logger.js");
+const log = (0, logger_js_1.createLogger)('forwarder');
+function computeApiKeyHash(headers) {
+    // Check common auth headers
+    const authHeader = headers['authorization'] || headers['x-api-key'];
+    if (!authHeader)
+        return undefined;
+    const key = authHeader.replace(/^Bearer\s+/i, '');
+    return (0, node_crypto_1.createHash)('sha256').update(key).digest('hex').slice(0, 16);
+}
+function bufferBody(req) {
+    return new Promise((resolve, reject) => {
+        const chunks = [];
+        req.on('data', (chunk) => chunks.push(chunk));
+        req.on('end', () => resolve(Buffer.concat(chunks)));
+        req.on('error', reject);
+    });
+}
+async function forwardRequest(req, res, options) {
+    const { provider, upstreamUrl, upstreamTimeout, pluginManager, sessionId, sessionSource } = options;
+    const startTime = Date.now();
+    const requestId = crypto.randomUUID();
+    // Buffer the request body
+    const rawBody = await bufferBody(req);
+    let bodyStr = rawBody.toString('utf-8');
+    let parsedBody = {};
+    try {
+        parsedBody = JSON.parse(bodyStr);
+    }
+    catch {
+        // Not JSON, use as-is
+    }
+    const model = provider.extractModel(parsedBody);
+    const isStreaming = Boolean(parsedBody.stream);
+    const reqHeaders = req.headers;
+    const apiKeyHash = computeApiKeyHash(reqHeaders);
+    // Build request context
+    const requestContext = {
+        id: requestId,
+        provider: provider.name,
+        model,
+        method: req.method ?? 'POST',
+        path: req.url ?? '/',
+        headers: reqHeaders,
+        body: bodyStr,
+        parsedBody,
+        isStreaming,
+        startTime,
+        sessionId,
+        sessionSource,
+        apiKeyHash,
+    };
+    // Run onRequest plugins
+    const pluginResult = await pluginManager.runOnRequest(requestContext);
+    // If a plugin short-circuited with a response (e.g., cache hit)
+    if (pluginResult.shortCircuit) {
+        const cached = pluginResult.shortCircuit;
+        res.writeHead(cached.statusCode, cached.headers);
+        res.end(cached.body);
+        return requestContext;
+    }
+    // If a plugin blocked the request (e.g., DLP)
+    if (pluginResult.blocked) {
+        res.writeHead(403, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({
+            error: {
+                message: pluginResult.blocked.reason,
+                type: 'gateway_blocked',
+            },
+        }));
+        return requestContext;
+    }
+    // If a plugin crashed in fail-closed mode
+    if (pluginResult.pluginError) {
+        res.writeHead(502, { 'content-type': 'application/json' });
+        res.end(JSON.stringify({
+            error: {
+                message: 'Security pipeline error',
+                detail: `Plugin ${pluginResult.pluginError.pluginName} failed`,
+                type: 'gateway_pipeline_error',
+            },
+        }));
+        return requestContext;
+    }
+    // Use modified body if plugins changed it
+    if (pluginResult.modifiedBody) {
+        bodyStr = pluginResult.modifiedBody;
+    }
+    // Forward to upstream
+    const url = new URL(upstreamUrl);
+    const isHttps = url.protocol === 'https:';
+    const outgoingHeaders = provider.transformHeaders(req.headers);
+    outgoingHeaders['host'] = url.host;
+    const hasBody = req.method !== 'GET' && req.method !== 'HEAD';
+    if (hasBody) {
+        outgoingHeaders['content-length'] = Buffer.byteLength(bodyStr).toString();
+    }
+    const makeRequest = isHttps ? node_https_1.request : node_http_1.request;
+    return new Promise((resolve) => {
+        const upstreamReq = makeRequest({
+            hostname: url.hostname,
+            port: url.port || (isHttps ? 443 : 80),
+            path: url.pathname + url.search,
+            method: req.method,
+            headers: outgoingHeaders,
+            timeout: upstreamTimeout,
+        }, (upstreamRes) => {
+            const statusCode = upstreamRes.statusCode ?? 500;
+            // Copy upstream response headers
+            const responseHeaders = {};
+            for (const [key, value] of Object.entries(upstreamRes.headers)) {
+                if (value)
+                    responseHeaders[key] = Array.isArray(value) ? value.join(', ') : value;
+            }
+            if (isStreaming) {
+                // Streaming: send headers immediately, forward chunks in real-time
+                res.writeHead(statusCode, responseHeaders);
+                handleStreamingResponse(upstreamRes, res, requestContext, pluginManager, provider, startTime)
+                    .then(() => resolve(requestContext));
+            }
+            else {
+                // Non-streaming: buffer response, run onResponse hook, then send
+                handleBufferedResponse(upstreamRes, res, statusCode, responseHeaders, requestContext, pluginManager, provider, startTime)
+                    .then(() => resolve(requestContext));
+            }
+        });
+        upstreamReq.on('error', (err) => {
+            log.error('Upstream request failed', { error: err.message, provider: provider.name });
+            if (!res.headersSent) {
+                res.writeHead(502, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({
+                    error: { message: 'Upstream request failed', type: 'gateway_error' },
+                }));
+            }
+            resolve(requestContext);
+        });
+        upstreamReq.on('timeout', () => {
+            upstreamReq.destroy();
+            if (!res.headersSent) {
+                res.writeHead(504, { 'content-type': 'application/json' });
+                res.end(JSON.stringify({
+                    error: { message: 'Upstream request timed out', type: 'gateway_error' },
+                }));
+            }
+            resolve(requestContext);
+        });
+        if (hasBody) {
+            upstreamReq.write(bodyStr);
+        }
+        upstreamReq.end();
+    });
+}
+// Cap accumulated body for post-send plugin processing.
+// Client always receives the full stream; only onResponseComplete sees the truncated body.
+const MAX_STREAMING_BODY = 2 * 1024 * 1024; // 2MB
+async function handleStreamingResponse(upstreamRes, clientRes, context, pluginManager, provider, startTime) {
+    let fullResponseData = '';
+    let bodyCapReached = false;
+    const sseEvents = [];
+    // Streaming tool guard: intercept tool_use SSE blocks when action=block
+    const useGuard = Boolean(context._toolGuardStreamBlock);
+    const guard = useGuard
+        ? new streaming_guard_js_1.StreamingToolGuard({ blockMinSeverity: context._toolGuardStreamBlock, rules: context._toolGuardRules }, (data) => clientRes.write(data))
+        : null;
+    // Accumulate raw events for the guard (keyed by parse position)
+    let rawEventBuffer = '';
+    const parser = new streaming_js_1.SSEParser((event) => {
+        const data = (0, streaming_js_1.parseSSEData)(event);
+        if (data) {
+            sseEvents.push(data);
+        }
+        if (guard) {
+            // Reconstruct the raw SSE text for this event
+            const rawEvent = (event.event ? `event: ${event.event}\n` : '') +
+                `data: ${event.data}\n\n`;
+            guard.processEvent(rawEvent, data);
+        }
+    });
+    return new Promise((resolve) => {
+        upstreamRes.on('data', (chunk) => {
+            const chunkStr = chunk.toString('utf-8');
+            // Cap accumulated body for post-send analysis; client still gets all data
+            if (!bodyCapReached) {
+                fullResponseData += chunkStr;
+                if (fullResponseData.length > MAX_STREAMING_BODY) {
+                    bodyCapReached = true;
+                }
+            }
+            if (guard) {
+                // Let the parser drive the guard (events are processed in the SSEParser callback)
+                parser.feed(chunkStr);
+            }
+            else {
+                // No guard: forward raw bytes unmodified, parse for inspection only
+                clientRes.write(chunk);
+                parser.feed(chunkStr);
+            }
+        });
+        upstreamRes.on('end', async () => {
+            parser.flush();
+            if (guard)
+                guard.flush();
+            clientRes.end();
+            // Propagate streaming guard block results to request context
+            if (guard && guard.results.length > 0) {
+                const blocked = guard.results.filter(r => r.blocked);
+                if (blocked.length > 0) {
+                    context.toolGuardHit = true;
+                    context.toolGuardFindings = blocked.length;
+                }
+            }
+            const latencyMs = Date.now() - startTime;
+            // Extract usage by merging across all SSE events (take max per field).
+            // Anthropic splits usage: input_tokens in message_start, output_tokens in message_delta.
+            const usage = { inputTokens: 0, outputTokens: 0, cacheCreationTokens: 0, cacheReadTokens: 0 };
+            for (const event of sseEvents) {
+                const extracted = provider.extractUsage(event);
+                if (extracted.inputTokens > usage.inputTokens)
+                    usage.inputTokens = extracted.inputTokens;
+                if (extracted.outputTokens > usage.outputTokens)
+                    usage.outputTokens = extracted.outputTokens;
+                if ((extracted.cacheCreationTokens ?? 0) > usage.cacheCreationTokens)
+                    usage.cacheCreationTokens = extracted.cacheCreationTokens ?? 0;
+                if ((extracted.cacheReadTokens ?? 0) > usage.cacheReadTokens)
+                    usage.cacheReadTokens = extracted.cacheReadTokens ?? 0;
+            }
+            const completeContext = {
+                request: context,
+                statusCode: upstreamRes.statusCode ?? 200,
+                body: fullResponseData,
+                parsedBody: null,
+                usage,
+                latencyMs,
+                isStreaming: true,
+                sseEvents,
+            };
+            await pluginManager.runOnResponseComplete(completeContext);
+            resolve();
+        });
+        upstreamRes.on('error', () => {
+            if (guard)
+                guard.flush();
+            clientRes.end();
+            resolve();
+        });
+    });
+}
+async function handleBufferedResponse(upstreamRes, clientRes, statusCode, responseHeaders, context, pluginManager, provider, startTime) {
+    return new Promise((resolve) => {
+        const chunks = [];
+        upstreamRes.on('data', (chunk) => {
+            chunks.push(chunk);
+        });
+        upstreamRes.on('end', async () => {
+            const body = Buffer.concat(chunks);
+            let bodyStr = body.toString('utf-8');
+            const latencyMs = Date.now() - startTime;
+            let parsedBody = null;
+            try {
+                parsedBody = JSON.parse(bodyStr);
+            }
+            catch {
+                // Not JSON
+            }
+            // Run onResponse hook (pre-send interception)
+            const interceptContext = {
+                request: context,
+                statusCode,
+                headers: responseHeaders,
+                body: bodyStr,
+                parsedBody,
+                isStreaming: false,
+            };
+            const hookResult = await pluginManager.runOnResponse(interceptContext);
+            if (hookResult.blocked) {
+                // Block: send error to client instead of the LLM response
+                clientRes.writeHead(403, { 'content-type': 'application/json' });
+                clientRes.end(JSON.stringify({
+                    error: {
+                        message: hookResult.blocked.reason,
+                        type: 'gateway_response_blocked',
+                    },
+                }));
+            }
+            else if (hookResult.pluginError) {
+                // Plugin crashed in fail-closed mode
+                clientRes.writeHead(502, { 'content-type': 'application/json' });
+                clientRes.end(JSON.stringify({
+                    error: {
+                        message: 'Security pipeline error',
+                        detail: `Plugin ${hookResult.pluginError.pluginName} failed`,
+                        type: 'gateway_pipeline_error',
+                    },
+                }));
+            }
+            else {
+                // Send response (original or modified)
+                if (hookResult.modifiedBody) {
+                    bodyStr = hookResult.modifiedBody;
+                }
+                // We buffered the response, so set exact content-length and remove chunked encoding
+                delete responseHeaders['transfer-encoding'];
+                responseHeaders['content-length'] = Buffer.byteLength(bodyStr).toString();
+                clientRes.writeHead(statusCode, responseHeaders);
+                clientRes.write(bodyStr);
+                clientRes.end();
+            }
+            const usage = parsedBody
+                ? provider.extractUsage(parsedBody)
+                : { inputTokens: 0, outputTokens: 0 };
+            const completeContext = {
+                request: context,
+                statusCode,
+                body: bodyStr,
+                parsedBody,
+                usage: {
+                    inputTokens: usage.inputTokens,
+                    outputTokens: usage.outputTokens,
+                    cacheCreationTokens: usage.cacheCreationTokens ?? 0,
+                    cacheReadTokens: usage.cacheReadTokens ?? 0,
+                },
+                latencyMs,
+                isStreaming: false,
+            };
+            await pluginManager.runOnResponseComplete(completeContext);
+            resolve();
+        });
+        upstreamRes.on('error', () => {
+            clientRes.end();
+            resolve();
+        });
+    });
+}
+//# sourceMappingURL=forwarder.js.map