palaryn 0.1.0

package/dist/tests/unit/forward-proxy.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"forward-proxy.test.d.ts","sourceRoot":"","sources":["../../../tests/unit/forward-proxy.test.ts"],"names":[],"mappings":""}

package/dist/tests/unit/forward-proxy.test.js

@@ -0,0 +1,621 @@
+"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 });
+const http = __importStar(require("http"));
+const proxy_1 = require("../../src/proxy");
+const auth_1 = require("../../src/middleware/auth");
+// ---------------------------------------------------------------------------
+// buildToolCallFromProxy tests
+// ---------------------------------------------------------------------------
+describe('buildToolCallFromProxy', () => {
+    it('should build a ToolCall from a GET request', () => {
+        const tc = (0, proxy_1.buildToolCallFromProxy)('GET', 'http://api.example.com/v1/data?q=test', { 'accept': 'application/json', 'host': 'api.example.com' }, undefined, 'ws_123', 'agent_456');
+        expect(tc.tool.name).toBe('http.get');
+        expect(tc.tool.capability).toBe('read');
+        expect(tc.args.method).toBe('GET');
+        expect(tc.args.url).toBe('http://api.example.com/v1/data?q=test');
+        expect(tc.workspace_id).toBe('ws_123');
+        expect(tc.actor.id).toBe('agent_456');
+        expect(tc.actor.type).toBe('agent');
+        expect(tc.source.platform).toBe('forward_proxy');
+        expect(tc.tool_call_id).toBeDefined();
+        expect(tc.task_id).toBeDefined();
+        expect(tc.context?.labels).toContain('proxy');
+        expect(tc.context?.labels).toContain('api.example.com');
+    });
+    it('should build a ToolCall from a POST request with JSON body', () => {
+        const tc = (0, proxy_1.buildToolCallFromProxy)('POST', 'http://api.example.com/v1/chat', { 'content-type': 'application/json' }, JSON.stringify({ message: 'hello' }), 'ws_123', 'agent_456');
+        expect(tc.tool.name).toBe('http.post');
+        expect(tc.tool.capability).toBe('write');
+        expect(tc.args.method).toBe('POST');
+        expect(tc.args.body).toEqual({ message: 'hello' });
+    });
+    it('should keep non-JSON body as string', () => {
+        const tc = (0, proxy_1.buildToolCallFromProxy)('POST', 'http://api.example.com/upload', { 'content-type': 'text/plain' }, 'plain text body', 'ws_123', 'agent_456');
+        expect(tc.args.body).toBe('plain text body');
+    });
+    it('should map DELETE to delete capability', () => {
+        const tc = (0, proxy_1.buildToolCallFromProxy)('DELETE', 'http://api.example.com/v1/resource/123', {}, undefined, 'ws_123', 'agent_456');
+        expect(tc.tool.name).toBe('http.delete');
+        expect(tc.tool.capability).toBe('delete');
+    });
+    it('should map HEAD and OPTIONS to read capability', () => {
+        const head = (0, proxy_1.buildToolCallFromProxy)('HEAD', 'http://example.com', {}, undefined, 'ws', 'a');
+        const options = (0, proxy_1.buildToolCallFromProxy)('OPTIONS', 'http://example.com', {}, undefined, 'ws', 'a');
+        expect(head.tool.capability).toBe('read');
+        expect(options.tool.capability).toBe('read');
+    });
+    it('should map PUT and PATCH to write capability', () => {
+        const put = (0, proxy_1.buildToolCallFromProxy)('PUT', 'http://example.com', {}, undefined, 'ws', 'a');
+        const patch = (0, proxy_1.buildToolCallFromProxy)('PATCH', 'http://example.com', {}, undefined, 'ws', 'a');
+        expect(put.tool.capability).toBe('write');
+        expect(patch.tool.capability).toBe('write');
+    });
+    it('should strip proxy-specific and sensitive headers from forwarded headers', () => {
+        const tc = (0, proxy_1.buildToolCallFromProxy)('GET', 'http://example.com', {
+            'proxy-authorization': 'Basic dXNlcjpwYXNz',
+            'proxy-connection': 'keep-alive',
+            'x-palaryn-workspace': 'ws_override',
+            'x-palaryn-actor': 'custom_actor',
+            'accept': 'application/json',
+            'authorization': 'Bearer token123',
+            'cookie': 'session=abc',
+            'x-api-key': 'sk-secret',
+        }, undefined, 'ws_123', 'agent_456');
+        const forwardHeaders = tc.args.headers;
+        expect(forwardHeaders['proxy-authorization']).toBeUndefined();
+        expect(forwardHeaders['proxy-connection']).toBeUndefined();
+        expect(forwardHeaders['x-palaryn-workspace']).toBeUndefined();
+        expect(forwardHeaders['x-palaryn-actor']).toBeUndefined();
+        expect(forwardHeaders['authorization']).toBeUndefined();
+        expect(forwardHeaders['cookie']).toBeUndefined();
+        expect(forwardHeaders['x-api-key']).toBeUndefined();
+        expect(forwardHeaders['accept']).toBe('application/json');
+    });
+});
+// ---------------------------------------------------------------------------
+// parseProxyAuth tests
+// ---------------------------------------------------------------------------
+describe('parseProxyAuth', () => {
+    const baseAuthConfig = {
+        enabled: true,
+        api_keys: {
+            'valid-key-123': { workspace_id: 'ws_1', description: 'Test key' },
+            'revoked-key': { workspace_id: 'ws_2', description: 'Revoked', revoked: true },
+            'expired-key': { workspace_id: 'ws_3', description: 'Expired', expires_at: '2020-01-01T00:00:00Z' },
+        },
+    };
+    const baseProxyConfig = {
+        enabled: true,
+        port: 3128,
+        require_auth: true,
+    };
+    it('should authenticate with valid Proxy-Authorization Basic header', () => {
+        const encoded = Buffer.from('ws_1:valid-key-123').toString('base64');
+        const result = (0, auth_1.parseProxyAuth)({ 'proxy-authorization': `Basic ${encoded}` }, baseProxyConfig, baseAuthConfig);
+        expect(result.authenticated).toBe(true);
+        expect(result.workspace_id).toBe('ws_1');
+        expect(result.api_key).toBe('valid-key-123');
+    });
+    it('should reject invalid Proxy-Authorization format', () => {
+        const result = (0, auth_1.parseProxyAuth)({ 'proxy-authorization': 'Bearer token123' }, baseProxyConfig, baseAuthConfig);
+        expect(result.authenticated).toBe(false);
+        expect(result.error).toContain('Invalid Proxy-Authorization format');
+    });
+    it('should reject missing colon in credentials', () => {
+        const encoded = Buffer.from('noColon').toString('base64');
+        const result = (0, auth_1.parseProxyAuth)({ 'proxy-authorization': `Basic ${encoded}` }, baseProxyConfig, baseAuthConfig);
+        expect(result.authenticated).toBe(false);
+        expect(result.error).toContain('Expected: workspace_id:api_key');
+    });
+    it('should reject empty workspace_id or api_key', () => {
+        const encoded = Buffer.from(':api_key').toString('base64');
+        const result = (0, auth_1.parseProxyAuth)({ 'proxy-authorization': `Basic ${encoded}` }, baseProxyConfig, baseAuthConfig);
+        expect(result.authenticated).toBe(false);
+        expect(result.error).toContain('Empty workspace_id or api_key');
+    });
+    it('should reject invalid API key when auth is enabled', () => {
+        const encoded = Buffer.from('ws_1:wrong-key').toString('base64');
+        const result = (0, auth_1.parseProxyAuth)({ 'proxy-authorization': `Basic ${encoded}` }, baseProxyConfig, baseAuthConfig);
+        expect(result.authenticated).toBe(false);
+        expect(result.error).toContain('Invalid API key');
+    });
+    it('should reject revoked API key', () => {
+        const encoded = Buffer.from('ws_2:revoked-key').toString('base64');
+        const result = (0, auth_1.parseProxyAuth)({ 'proxy-authorization': `Basic ${encoded}` }, baseProxyConfig, baseAuthConfig);
+        expect(result.authenticated).toBe(false);
+        expect(result.error).toContain('revoked');
+    });
+    it('should reject expired API key', () => {
+        const encoded = Buffer.from('ws_3:expired-key').toString('base64');
+        const result = (0, auth_1.parseProxyAuth)({ 'proxy-authorization': `Basic ${encoded}` }, baseProxyConfig, baseAuthConfig);
+        expect(result.authenticated).toBe(false);
+        expect(result.error).toContain('expired');
+    });
+    it('should use sidecar defaults when no auth header present', () => {
+        const sidecarConfig = {
+            ...baseProxyConfig,
+            default_workspace_id: 'ws_sidecar',
+            default_actor_id: 'agent_sidecar',
+        };
+        const result = (0, auth_1.parseProxyAuth)({}, sidecarConfig, baseAuthConfig);
+        expect(result.authenticated).toBe(true);
+        expect(result.workspace_id).toBe('ws_sidecar');
+        expect(result.actor_id).toBe('agent_sidecar');
+    });
+    it('should override sidecar workspace with X-Palaryn-Workspace header', () => {
+        const sidecarConfig = {
+            ...baseProxyConfig,
+            default_workspace_id: 'ws_sidecar',
+        };
+        const result = (0, auth_1.parseProxyAuth)({ 'x-palaryn-workspace': 'ws_override' }, sidecarConfig, baseAuthConfig);
+        expect(result.authenticated).toBe(true);
+        expect(result.workspace_id).toBe('ws_override');
+    });
+    it('should use X-Palaryn-Actor header with Proxy-Authorization', () => {
+        const encoded = Buffer.from('ws_1:valid-key-123').toString('base64');
+        const result = (0, auth_1.parseProxyAuth)({
+            'proxy-authorization': `Basic ${encoded}`,
+            'x-palaryn-actor': 'custom_agent',
+        }, baseProxyConfig, baseAuthConfig);
+        expect(result.authenticated).toBe(true);
+        expect(result.actor_id).toBe('custom_agent');
+    });
+    it('should allow unauthenticated requests when require_auth is false', () => {
+        const permissiveConfig = {
+            ...baseProxyConfig,
+            require_auth: false,
+        };
+        const result = (0, auth_1.parseProxyAuth)({}, permissiveConfig, baseAuthConfig);
+        expect(result.authenticated).toBe(true);
+        expect(result.workspace_id).toBe('ws_default');
+        expect(result.actor_id).toBe('proxy:anonymous');
+    });
+    it('should reject unauthenticated requests when require_auth is true', () => {
+        const result = (0, auth_1.parseProxyAuth)({}, baseProxyConfig, baseAuthConfig);
+        expect(result.authenticated).toBe(false);
+        expect(result.error).toContain('Proxy-Authorization required');
+    });
+    it('should authenticate via X-Palaryn-Workspace header when require_auth is false', () => {
+        const permissiveConfig = {
+            ...baseProxyConfig,
+            require_auth: false,
+        };
+        const result = (0, auth_1.parseProxyAuth)({ 'x-palaryn-workspace': 'ws_header' }, permissiveConfig, baseAuthConfig);
+        expect(result.authenticated).toBe(true);
+        expect(result.workspace_id).toBe('ws_header');
+        expect(result.actor_id).toBe('proxy:ws_header');
+    });
+    it('should reject X-Palaryn-Workspace header when require_auth is true', () => {
+        const result = (0, auth_1.parseProxyAuth)({ 'x-palaryn-workspace': 'ws_header' }, baseProxyConfig, baseAuthConfig);
+        expect(result.authenticated).toBe(false);
+        expect(result.error).toContain('Proxy-Authorization required');
+    });
+    it('should skip API key validation when auth is disabled', () => {
+        const disabledAuth = {
+            enabled: false,
+            api_keys: {},
+        };
+        const encoded = Buffer.from('ws_any:any-key').toString('base64');
+        const result = (0, auth_1.parseProxyAuth)({ 'proxy-authorization': `Basic ${encoded}` }, baseProxyConfig, disabledAuth);
+        expect(result.authenticated).toBe(true);
+        expect(result.workspace_id).toBe('ws_any');
+        expect(result.api_key).toBe('any-key');
+    });
+});
+// ---------------------------------------------------------------------------
+// createForwardProxy tests
+// ---------------------------------------------------------------------------
+describe('createForwardProxy', () => {
+    let targetServer;
+    let targetPort;
+    let proxyServer;
+    let proxyPort;
+    // Mock gateway
+    const mockPreExecute = jest.fn();
+    const mockPostExecute = jest.fn();
+    const mockRateLimiterCheck = jest.fn().mockReturnValue({ allowed: true, current: 1, limit: 100 });
+    const mockAuditLogToolCallReceived = jest.fn();
+    const mockGateway = {
+        preExecute: mockPreExecute,
+        postExecute: mockPostExecute,
+        getRateLimiter: () => ({ check: mockRateLimiterCheck }),
+        getAuditLogger: () => ({ logToolCallReceived: mockAuditLogToolCallReceived }),
+    };
+    function testConfig(overrides) {
+        return {
+            port: 0,
+            host: '127.0.0.1',
+            auth: {
+                enabled: false,
+                api_keys: {},
+            },
+            policy: {
+                pack_path: './policy-packs/dev_fast.yaml',
+                default_effect: 'ALLOW',
+                hot_reload: false,
+            },
+            dlp: {
+                enabled: false,
+                scan_args: false,
+                scan_output: false,
+                secrets_detection: false,
+                pii_detection: false,
+                default_redaction_method: 'mask',
+            },
+            budget: {
+                task_budget_usd: 100,
+                max_steps_per_task: 1000,
+                max_retries_per_call: 3,
+                max_wall_clock_ms: 300000,
+            },
+            audit: {
+                enabled: false,
+                log_dir: '',
+                console_output: false,
+                retention_days: 30,
+            },
+            executor: {
+                http: { timeout_ms: 15000, max_retries: 3, backoff_base_ms: 1000 },
+                cache: { enabled: false, ttl_ms: 0 },
+            },
+            approval: {
+                enabled: false,
+                token_secret: 'test-secret',
+                default_ttl_seconds: 3600,
+            },
+            proxy: {
+                enabled: true,
+                port: 0,
+                require_auth: false,
+                ssrf_protection: false,
+            },
+            ...overrides,
+        };
+    }
+    beforeAll((done) => {
+        // Start a target HTTP server for the proxy to forward to
+        targetServer = http.createServer((req, res) => {
+            if (req.url === '/api/data' && req.method === 'GET') {
+                res.writeHead(200, { 'Content-Type': 'application/json' });
+                res.end(JSON.stringify({ data: 'success', method: 'GET' }));
+            }
+            else if (req.url === '/api/create' && req.method === 'POST') {
+                let body = '';
+                req.on('data', (chunk) => (body += chunk));
+                req.on('end', () => {
+                    res.writeHead(201, { 'Content-Type': 'application/json' });
+                    res.end(JSON.stringify({ created: true, received: body }));
+                });
+            }
+            else if (req.url === '/api/slow') {
+                // Do not respond (simulate timeout)
+            }
+            else {
+                res.writeHead(404);
+                res.end('Not found');
+            }
+        });
+        targetServer.listen(0, '127.0.0.1', () => {
+            targetPort = targetServer.address().port;
+            done();
+        });
+    });
+    afterAll((done) => {
+        targetServer.close(done);
+    });
+    beforeEach(() => {
+        mockPreExecute.mockReset();
+        mockPostExecute.mockReset();
+        mockPostExecute.mockResolvedValue({});
+        mockRateLimiterCheck.mockReset();
+        mockRateLimiterCheck.mockReturnValue({ allowed: true, current: 1, limit: 100 });
+        mockAuditLogToolCallReceived.mockReset();
+    });
+    afterEach((done) => {
+        if (proxyServer) {
+            proxyServer.close(() => done());
+        }
+        else {
+            done();
+        }
+    });
+    function startProxy(config) {
+        return new Promise((resolve) => {
+            proxyServer = (0, proxy_1.createForwardProxy)(mockGateway, testConfig(config));
+            proxyServer.listen(0, () => {
+                proxyPort = proxyServer.server.address().port;
+                resolve(proxyPort);
+            });
+        });
+    }
+    function proxyRequest(method, targetUrl, body, headers) {
+        return new Promise((resolve, reject) => {
+            let host = '127.0.0.1';
+            try {
+                const url = new URL(targetUrl);
+                host = url.host;
+            }
+            catch {
+                // Relative URL — just send as-is
+            }
+            const options = {
+                hostname: '127.0.0.1',
+                port: proxyPort,
+                method,
+                path: targetUrl, // Absolute URL for proxy protocol
+                headers: {
+                    'Host': host,
+                    ...headers,
+                },
+            };
+            const req = http.request(options, (res) => {
+                let data = '';
+                res.on('data', (chunk) => (data += chunk));
+                res.on('end', () => {
+                    resolve({ status: res.statusCode || 0, headers: res.headers, body: data });
+                });
+            });
+            req.on('error', reject);
+            if (body)
+                req.write(body);
+            req.end();
+        });
+    }
+    it('should return 400 for non-proxy requests (relative URL)', async () => {
+        await startProxy();
+        const res = await proxyRequest('GET', '/not-a-proxy-request');
+        expect(res.status).toBe(400);
+        expect(JSON.parse(res.body).error).toContain('Not a proxy request');
+    });
+    it('should forward allowed GET requests and return response', async () => {
+        await startProxy();
+        const targetUrl = `http://127.0.0.1:${targetPort}/api/data`;
+        mockPreExecute.mockResolvedValue({
+            allowed: true,
+            stepTimings: {},
+            startTime: Date.now(),
+        });
+        const res = await proxyRequest('GET', targetUrl);
+        expect(res.status).toBe(200);
+        const parsed = JSON.parse(res.body);
+        expect(parsed.data).toBe('success');
+        expect(mockPreExecute).toHaveBeenCalledTimes(1);
+        // Verify the ToolCall passed to preExecute
+        const toolCall = mockPreExecute.mock.calls[0][0];
+        expect(toolCall.tool.name).toBe('http.get');
+        expect(toolCall.tool.capability).toBe('read');
+        expect(toolCall.args.url).toBe(targetUrl);
+        expect(toolCall.workspace_id).toBe('ws_default');
+    });
+    it('should forward POST requests with body', async () => {
+        await startProxy();
+        const targetUrl = `http://127.0.0.1:${targetPort}/api/create`;
+        mockPreExecute.mockResolvedValue({
+            allowed: true,
+            stepTimings: {},
+            startTime: Date.now(),
+        });
+        const res = await proxyRequest('POST', targetUrl, JSON.stringify({ test: true }), {
+            'Content-Type': 'application/json',
+        });
+        expect(res.status).toBe(201);
+        const parsed = JSON.parse(res.body);
+        expect(parsed.created).toBe(true);
+    });
+    it('should return 403 when preExecute denies the request', async () => {
+        await startProxy();
+        const targetUrl = `http://127.0.0.1:${targetPort}/api/data`;
+        mockPreExecute.mockResolvedValue({
+            allowed: false,
+            result: {
+                tool_call_id: 'tc_1',
+                task_id: 'task_1',
+                status: 'blocked',
+                policy: { decision: 'deny', rule_id: 'block_domain', reasons: ['Domain blocked by policy'] },
+                dlp: { detected: [], redactions: [], severity: 'low' },
+                budget: { estimated_cost_usd: 0, spent_cost_usd_task: 0, remaining_cost_usd_task: 0 },
+                timing: { started_at: new Date().toISOString(), duration_ms: 1 },
+            },
+            stepTimings: {},
+            startTime: Date.now(),
+        });
+        const res = await proxyRequest('GET', targetUrl);
+        expect(res.status).toBe(403);
+        const parsed = JSON.parse(res.body);
+        expect(parsed.status).toBe('blocked');
+        expect(parsed.policy.decision).toBe('deny');
+    });
+    it('should return 202 when preExecute requires approval', async () => {
+        await startProxy();
+        const targetUrl = `http://127.0.0.1:${targetPort}/api/data`;
+        mockPreExecute.mockResolvedValue({
+            allowed: false,
+            result: {
+                tool_call_id: 'tc_1',
+                task_id: 'task_1',
+                status: 'needs_approval',
+                policy: { decision: 'require_approval', rule_id: 'require_human', reasons: ['Requires approval'] },
+                dlp: { detected: [], redactions: [], severity: 'low' },
+                budget: { estimated_cost_usd: 0, spent_cost_usd_task: 0, remaining_cost_usd_task: 0 },
+                timing: { started_at: new Date().toISOString(), duration_ms: 1 },
+                approval: { approval_id: 'apr_1', token: 'tok_1' },
+            },
+            stepTimings: {},
+            startTime: Date.now(),
+        });
+        const res = await proxyRequest('GET', targetUrl);
+        expect(res.status).toBe(202);
+    });
+    it('should return 407 when auth is required but missing', async () => {
+        await startProxy({
+            auth: { enabled: true, api_keys: { 'test-key': { workspace_id: 'ws_1' } } },
+            proxy: { enabled: true, port: 0, require_auth: true, ssrf_protection: false },
+        });
+        const targetUrl = `http://127.0.0.1:${targetPort}/api/data`;
+        const res = await proxyRequest('GET', targetUrl);
+        expect(res.status).toBe(407);
+        expect(res.headers['proxy-authenticate']).toBe('Basic realm="Palaryn Proxy"');
+    });
+    it('should authenticate with Proxy-Authorization header', async () => {
+        await startProxy({
+            auth: { enabled: true, api_keys: { 'my-key': { workspace_id: 'ws_proxy' } } },
+            proxy: { enabled: true, port: 0, require_auth: true, ssrf_protection: false },
+        });
+        const targetUrl = `http://127.0.0.1:${targetPort}/api/data`;
+        const encoded = Buffer.from('ws_proxy:my-key').toString('base64');
+        mockPreExecute.mockResolvedValue({
+            allowed: true,
+            stepTimings: {},
+            startTime: Date.now(),
+        });
+        const res = await proxyRequest('GET', targetUrl, undefined, {
+            'Proxy-Authorization': `Basic ${encoded}`,
+        });
+        expect(res.status).toBe(200);
+        // Verify workspace was set correctly
+        const toolCall = mockPreExecute.mock.calls[0][0];
+        expect(toolCall.workspace_id).toBe('ws_proxy');
+    });
+    it('should call postExecute after successful forwarding', async () => {
+        await startProxy();
+        const targetUrl = `http://127.0.0.1:${targetPort}/api/data`;
+        const pre = {
+            allowed: true,
+            stepTimings: {},
+            startTime: Date.now(),
+            policyResult: { decision: 'allow', rule_id: 'default', rule_name: 'Default allow', reasons: [] },
+            argsDlp: { detected: [], redactions: [], severity: 'low' },
+            budgetCheck: { report: { estimated_cost_usd: 0 }, allowed: true },
+        };
+        mockPreExecute.mockResolvedValue(pre);
+        await proxyRequest('GET', targetUrl);
+        // postExecute runs in background, give it a tick
+        await new Promise(resolve => setTimeout(resolve, 100));
+        expect(mockPostExecute).toHaveBeenCalledTimes(1);
+        const [tc, output, passedPre] = mockPostExecute.mock.calls[0];
+        expect(tc.tool.name).toBe('http.get');
+        expect(output.http_status).toBe(200);
+        expect(typeof output.body).toBe('string');
+    });
+    it('should handle CONNECT tunnel requests', async () => {
+        await startProxy();
+        // Send CONNECT request
+        const result = await new Promise((resolve, reject) => {
+            const req = http.request({
+                hostname: '127.0.0.1',
+                port: proxyPort,
+                method: 'CONNECT',
+                path: '127.0.0.1:' + targetPort,
+            });
+            req.on('connect', (res, socket, head) => {
+                // We got a tunnel established response
+                resolve({ status: res.statusCode?.toString() || '', socket });
+                socket.destroy();
+            });
+            req.on('error', (err) => {
+                // CONNECT may fail because we mock gateway - that's fine for unit test
+                // The point is the handler ran
+                resolve({ status: 'error', socket: null });
+            });
+            req.end();
+        });
+        // The CONNECT handler should have been invoked
+        // With mock gateway, preExecute should have been called
+        expect(mockPreExecute).toHaveBeenCalled();
+    });
+    // -- S2: Passthrough domains should still run rate limiting and audit ------
+    it('should run rate limiting for passthrough domains (S2)', async () => {
+        await startProxy({
+            proxy: {
+                enabled: true,
+                port: 0,
+                require_auth: false,
+                ssrf_protection: false,
+                passthrough_domains: ['127.0.0.1'],
+            },
+        });
+        const targetUrl = `http://127.0.0.1:${targetPort}/api/data`;
+        const res = await proxyRequest('GET', targetUrl);
+        // Request should be forwarded (passthrough skips policy)
+        expect(res.status).toBe(200);
+        // Rate limiter should have been checked
+        expect(mockRateLimiterCheck).toHaveBeenCalledTimes(1);
+        // preExecute should NOT have been called (passthrough skips full pipeline)
+        expect(mockPreExecute).not.toHaveBeenCalled();
+    });
+    it('should return 429 when passthrough domain hits rate limit (S2)', async () => {
+        await startProxy({
+            proxy: {
+                enabled: true,
+                port: 0,
+                require_auth: false,
+                ssrf_protection: false,
+                passthrough_domains: ['127.0.0.1'],
+            },
+        });
+        mockRateLimiterCheck.mockReturnValue({
+            allowed: false,
+            current: 101,
+            limit: 100,
+            blocked_by: 'actor',
+        });
+        const targetUrl = `http://127.0.0.1:${targetPort}/api/data`;
+        const res = await proxyRequest('GET', targetUrl);
+        expect(res.status).toBe(429);
+        const body = JSON.parse(res.body);
+        expect(body.error_code).toBe('RATE_LIMIT_EXCEEDED');
+        expect(body.error).toContain('Rate limit exceeded');
+    });
+    it('should run audit logging for passthrough domains (S2)', async () => {
+        await startProxy({
+            proxy: {
+                enabled: true,
+                port: 0,
+                require_auth: false,
+                ssrf_protection: false,
+                passthrough_domains: ['127.0.0.1'],
+            },
+        });
+        const targetUrl = `http://127.0.0.1:${targetPort}/api/data`;
+        await proxyRequest('GET', targetUrl);
+        // Audit logger should have been called
+        expect(mockAuditLogToolCallReceived).toHaveBeenCalledTimes(1);
+        const toolCall = mockAuditLogToolCallReceived.mock.calls[0][0];
+        expect(toolCall.tool.name).toBe('http.get');
+        expect(toolCall.args.url).toBe(targetUrl);
+    });
+});
+//# sourceMappingURL=forward-proxy.test.js.map