@openchamber/web 1.9.2 → 1.9.3

package/server/lib/terminal/runtime.js

@@ -2,8 +2,12 @@ import { WebSocketServer } from 'ws';
 import {
   TERMINAL_INPUT_WS_MAX_PAYLOAD_BYTES,
   TERMINAL_INPUT_WS_PATH,
+  TERMINAL_OUTPUT_REPLAY_MAX_BYTES,
+  appendTerminalOutputReplayChunk,
+  createTerminalOutputReplayBuffer,
   createTerminalInputWsControlFrame,
   isRebindRateLimited,
+  listTerminalOutputReplayChunksSince,
   normalizeTerminalInputWsMessageToText,
   parseRequestPathname,
   pruneRebindTimestamps,
@@ -150,8 +154,10 @@ export function createTerminalRuntime({
   };
 
   const terminalSessions = new Map();
+  const terminalWsConnections = new Set();
   const MAX_TERMINAL_SESSIONS = 20;
   const TERMINAL_IDLE_TIMEOUT = 30 * 60 * 1000;
+  const terminalRuntimeName = typeof globalThis.Bun === 'undefined' ? 'node' : 'bun';
   const sanitizeTerminalEnv = (env) => {
     const next = { ...env };
     delete next.BASH_XTRACEFD;
@@ -159,13 +165,22 @@ export function createTerminalRuntime({
     delete next.ENV;
     return next;
   };
-  const terminalInputCapabilities = {
+  const terminalTransportCapabilities = {
     input: {
       preferred: 'ws',
       transports: ['http', 'ws'],
       ws: {
         path: TERMINAL_INPUT_WS_PATH,
-        v: 1,
+        v: 2,
+        enc: 'text+json-bin-control',
+      },
+    },
+    stream: {
+      preferred: 'ws',
+      transports: ['sse', 'ws'],
+      ws: {
+        path: TERMINAL_INPUT_WS_PATH,
+        v: 2,
         enc: 'text+json-bin-control',
       },
     },
@@ -189,13 +204,17 @@ export function createTerminalRuntime({
 
   terminalInputWsServer.on('connection', (socket) => {
     const connectionState = {
+      socket,
       boundSessionId: null,
       invalidFrames: 0,
       rebindTimestamps: [],
+      replayCursorBySession: new Map(),
       lastActivityAt: Date.now(),
     };
 
-    sendTerminalInputWsControl(socket, { t: 'ok', v: 1 });
+    terminalWsConnections.add(connectionState);
+
+    sendTerminalInputWsControl(socket, { t: 'ok', v: 2 });
 
     const heartbeatInterval = setInterval(() => {
       if (socket.readyState !== 1) {
@@ -231,7 +250,7 @@ export function createTerminalRuntime({
         }
 
         if (controlMessage.t === 'p') {
-          sendTerminalInputWsControl(socket, { t: 'po', v: 1 });
+          sendTerminalInputWsControl(socket, { t: 'po', v: 2 });
           return;
         }
 
@@ -268,9 +287,32 @@ export function createTerminalRuntime({
           return;
         }
 
+        const replaySinceRaw =
+          typeof controlMessage.r === 'number' && Number.isFinite(controlMessage.r)
+            ? Math.max(0, Math.trunc(controlMessage.r))
+            : 0;
+        const rememberedReplayCursor = connectionState.replayCursorBySession.get(nextSessionId) ?? 0;
+        const replaySince = Math.max(replaySinceRaw, rememberedReplayCursor);
+
         connectionState.rebindTimestamps.push(now);
         connectionState.boundSessionId = nextSessionId;
-        sendTerminalInputWsControl(socket, { t: 'bok', v: 1 });
+        sendTerminalInputWsControl(socket, {
+          t: 'bok',
+          v: 2,
+          s: nextSessionId,
+          runtime: terminalRuntimeName,
+          ptyBackend: targetSession.ptyBackend || 'unknown',
+        });
+
+        const replayChunks = listTerminalOutputReplayChunksSince(targetSession.outputReplayBuffer, replaySince);
+        for (const replayChunk of replayChunks) {
+          try {
+            socket.send(replayChunk.data);
+            connectionState.replayCursorBySession.set(nextSessionId, replayChunk.id);
+          } catch {
+            break;
+          }
+        }
         return;
       }
 
@@ -301,6 +343,8 @@ export function createTerminalRuntime({
 
     socket.on('close', () => {
       clearInterval(heartbeatInterval);
+      connectionState.boundSessionId = null;
+      terminalWsConnections.delete(connectionState);
     });
 
     socket.on('error', (error) => {
@@ -347,6 +391,56 @@ export function createTerminalRuntime({
     void handleUpgrade();
   });
 
+  const wireTerminalSession = (sessionId, session) => {
+    session.ptyProcess.onData((data) => {
+      session.lastActivity = Date.now();
+      const replayChunk = appendTerminalOutputReplayChunk(
+        session.outputReplayBuffer,
+        data,
+        TERMINAL_OUTPUT_REPLAY_MAX_BYTES
+      );
+
+      for (const wsConnection of terminalWsConnections) {
+        if (wsConnection.boundSessionId !== sessionId) {
+          continue;
+        }
+
+        if (!wsConnection.socket || wsConnection.socket.readyState !== 1) {
+          continue;
+        }
+
+        try {
+          wsConnection.socket.send(data);
+          if (replayChunk) {
+            wsConnection.replayCursorBySession.set(sessionId, replayChunk.id);
+          }
+        } catch {
+        }
+      }
+    });
+
+    session.ptyProcess.onExit(({ exitCode, signal }) => {
+      console.log(`Terminal session ${sessionId} exited with code ${exitCode}, signal ${signal}`);
+      for (const wsConnection of terminalWsConnections) {
+        if (wsConnection.boundSessionId !== sessionId) {
+          continue;
+        }
+
+        wsConnection.boundSessionId = null;
+        wsConnection.replayCursorBySession.delete(sessionId);
+        sendTerminalInputWsControl(wsConnection.socket, {
+          t: 'x',
+          v: 2,
+          s: sessionId,
+          exitCode,
+          signal,
+        });
+      }
+
+      terminalSessions.delete(sessionId);
+    });
+  };
+
   const idleSweepInterval = setInterval(() => {
     const now = Date.now();
     for (const [sessionId, session] of terminalSessions.entries()) {
@@ -399,17 +493,14 @@ export function createTerminalRuntime({
         cwd,
         lastActivity: Date.now(),
         clients: new Set(),
+        outputReplayBuffer: createTerminalOutputReplayBuffer(),
       };
 
       terminalSessions.set(sessionId, session);
-
-      ptyProcess.onExit(({ exitCode, signal }) => {
-        console.log(`Terminal session ${sessionId} exited with code ${exitCode}, signal ${signal}`);
-        terminalSessions.delete(sessionId);
-      });
+      wireTerminalSession(sessionId, session);
 
       console.log(`Created terminal session: ${sessionId} in ${cwd} using shell ${shell}`);
-      res.json({ sessionId, cols: cols || 80, rows: rows || 24, capabilities: terminalInputCapabilities });
+      res.json({ sessionId, cols: cols || 80, rows: rows || 24, capabilities: terminalTransportCapabilities });
     } catch (error) {
       console.error('Failed to create terminal session:', error);
       res.status(500).json({ error: error.message || 'Failed to create terminal session' });
@@ -433,9 +524,8 @@ export function createTerminalRuntime({
     session.clients.add(clientId);
     session.lastActivity = Date.now();
 
-    const runtime = typeof globalThis.Bun === 'undefined' ? 'node' : 'bun';
     const ptyBackend = session.ptyBackend || 'unknown';
-    res.write(`data: ${JSON.stringify({ type: 'connected', runtime, ptyBackend })}\n\n`);
+    res.write(`data: ${JSON.stringify({ type: 'connected', runtime: terminalRuntimeName, ptyBackend })}\n\n`);
 
     const heartbeatInterval = setInterval(() => {
       try {
@@ -501,7 +591,7 @@ export function createTerminalRuntime({
     req.on('close', cleanup);
     req.on('error', cleanup);
 
-    console.log(`Terminal connected: session=${sessionId} client=${clientId} runtime=${runtime} pty=${ptyBackend}`);
+    console.log(`Terminal connected: session=${sessionId} client=${clientId} runtime=${terminalRuntimeName} pty=${ptyBackend}`);
   });
 
   app.post('/api/terminal/:sessionId/input', express.text({ type: '*/*' }), (req, res) => {
@@ -613,17 +703,14 @@ export function createTerminalRuntime({
         cwd,
         lastActivity: Date.now(),
         clients: new Set(),
+        outputReplayBuffer: createTerminalOutputReplayBuffer(),
       };
 
       terminalSessions.set(newSessionId, session);
-
-      ptyProcess.onExit(({ exitCode, signal }) => {
-        console.log(`Terminal session ${newSessionId} exited with code ${exitCode}, signal ${signal}`);
-        terminalSessions.delete(newSessionId);
-      });
+      wireTerminalSession(newSessionId, session);
 
       console.log(`Restarted terminal session: ${sessionId} -> ${newSessionId} in ${cwd} using shell ${shell}`);
-      res.json({ sessionId: newSessionId, cols: cols || 80, rows: rows || 24, capabilities: terminalInputCapabilities });
+      res.json({ sessionId: newSessionId, cols: cols || 80, rows: rows || 24, capabilities: terminalTransportCapabilities });
     } catch (error) {
       console.error('Failed to restart terminal session:', error);
       res.status(500).json({ error: error.message || 'Failed to restart terminal session' });

package/server/lib/terminal/{input-ws-protocol.js → terminal-ws-protocol.js}

@@ -1,6 +1,6 @@
-export const TERMINAL_INPUT_WS_PATH = '/api/terminal/input-ws';
-export const TERMINAL_INPUT_WS_CONTROL_TAG_JSON = 0x01;
-export const TERMINAL_INPUT_WS_MAX_PAYLOAD_BYTES = 64 * 1024;
+export const TERMINAL_WS_PATH = '/api/terminal/ws';
+export const TERMINAL_WS_CONTROL_TAG_JSON = 0x01;
+export const TERMINAL_WS_MAX_PAYLOAD_BYTES = 64 * 1024;
 
 export const parseRequestPathname = (requestUrl) => {
   if (typeof requestUrl !== 'string' || requestUrl.length === 0) {
@@ -14,7 +14,9 @@ export const parseRequestPathname = (requestUrl) => {
   }
 };
 
-export const normalizeTerminalInputWsMessageToBuffer = (rawData) => {
+export const isTerminalWsPathname = (pathname) => pathname === TERMINAL_WS_PATH;
+
+export const normalizeTerminalWsMessageToBuffer = (rawData) => {
   if (Buffer.isBuffer(rawData)) {
     return rawData;
   }
@@ -26,21 +28,21 @@ export const normalizeTerminalInputWsMessageToBuffer = (rawData) => {
   return Buffer.from(rawData);
 };
 
-export const normalizeTerminalInputWsMessageToText = (rawData) => {
+export const normalizeTerminalWsMessageToText = (rawData) => {
   if (typeof rawData === 'string') {
     return rawData;
   }
 
-  return normalizeTerminalInputWsMessageToBuffer(rawData).toString('utf8');
+  return normalizeTerminalWsMessageToBuffer(rawData).toString('utf8');
 };
 
-export const readTerminalInputWsControlFrame = (rawData) => {
+export const readTerminalWsControlFrame = (rawData) => {
   if (!rawData) {
     return null;
   }
 
-  const buffer = normalizeTerminalInputWsMessageToBuffer(rawData);
-  if (buffer.length < 2 || buffer[0] !== TERMINAL_INPUT_WS_CONTROL_TAG_JSON) {
+  const buffer = normalizeTerminalWsMessageToBuffer(rawData);
+  if (buffer.length < 2 || buffer[0] !== TERMINAL_WS_CONTROL_TAG_JSON) {
     return null;
   }
 
@@ -55,9 +57,9 @@ export const readTerminalInputWsControlFrame = (rawData) => {
   }
 };
 
-export const createTerminalInputWsControlFrame = (payload) => {
+export const createTerminalWsControlFrame = (payload) => {
   const jsonBytes = Buffer.from(JSON.stringify(payload), 'utf8');
-  return Buffer.concat([Buffer.from([TERMINAL_INPUT_WS_CONTROL_TAG_JSON]), jsonBytes]);
+  return Buffer.concat([Buffer.from([TERMINAL_WS_CONTROL_TAG_JSON]), jsonBytes]);
 };
 
 export const pruneRebindTimestamps = (timestamps, now, windowMs) =>

package/server/lib/terminal/{input-ws-protocol.test.js → terminal-ws-protocol.test.js}

@@ -1,86 +1,93 @@
 import { describe, expect, it } from 'bun:test';
 
 import {
-  TERMINAL_INPUT_WS_CONTROL_TAG_JSON,
-  TERMINAL_INPUT_WS_PATH,
-  createTerminalInputWsControlFrame,
+  TERMINAL_WS_PATH,
+  TERMINAL_WS_CONTROL_TAG_JSON,
+  createTerminalWsControlFrame,
+  isTerminalWsPathname,
   isRebindRateLimited,
-  normalizeTerminalInputWsMessageToBuffer,
-  normalizeTerminalInputWsMessageToText,
+  normalizeTerminalWsMessageToBuffer,
+  normalizeTerminalWsMessageToText,
   parseRequestPathname,
   pruneRebindTimestamps,
-  readTerminalInputWsControlFrame,
-} from './input-ws-protocol.js';
+  readTerminalWsControlFrame,
+} from './terminal-ws-protocol.js';
 
-describe('terminal input websocket protocol', () => {
-  it('uses fixed websocket path', () => {
-    expect(TERMINAL_INPUT_WS_PATH).toBe('/api/terminal/input-ws');
+describe('terminal websocket protocol', () => {
+  it('uses fixed websocket paths', () => {
+    expect(TERMINAL_WS_PATH).toBe('/api/terminal/ws');
+  });
+
+  it('matches supported websocket pathnames', () => {
+    expect(isTerminalWsPathname('/api/terminal/ws')).toBe(true);
+    expect(isTerminalWsPathname('/api/terminal/input-ws')).toBe(false);
+    expect(isTerminalWsPathname('/api/terminal/other')).toBe(false);
   });
 
   it('encodes control frames with control tag prefix', () => {
-    const frame = createTerminalInputWsControlFrame({ t: 'ok', v: 1 });
-    expect(frame[0]).toBe(TERMINAL_INPUT_WS_CONTROL_TAG_JSON);
+    const frame = createTerminalWsControlFrame({ t: 'ok', v: 1 });
+    expect(frame[0]).toBe(TERMINAL_WS_CONTROL_TAG_JSON);
   });
 
   it('roundtrips control frame payload', () => {
     const payload = { t: 'b', s: 'abc123', v: 1 };
-    const frame = createTerminalInputWsControlFrame(payload);
-    expect(readTerminalInputWsControlFrame(frame)).toEqual(payload);
+    const frame = createTerminalWsControlFrame(payload);
+    expect(readTerminalWsControlFrame(frame)).toEqual(payload);
   });
 
   it('rejects control frame without protocol tag', () => {
     const frame = Buffer.from(JSON.stringify({ t: 'b', s: 'abc123' }), 'utf8');
-    expect(readTerminalInputWsControlFrame(frame)).toBeNull();
+    expect(readTerminalWsControlFrame(frame)).toBeNull();
   });
 
   it('rejects malformed control json', () => {
     const frame = Buffer.concat([
-      Buffer.from([TERMINAL_INPUT_WS_CONTROL_TAG_JSON]),
+      Buffer.from([TERMINAL_WS_CONTROL_TAG_JSON]),
       Buffer.from('{not json', 'utf8'),
     ]);
-    expect(readTerminalInputWsControlFrame(frame)).toBeNull();
+    expect(readTerminalWsControlFrame(frame)).toBeNull();
   });
 
   it('rejects empty control payloads', () => {
-    expect(readTerminalInputWsControlFrame(null)).toBeNull();
-    expect(readTerminalInputWsControlFrame(undefined)).toBeNull();
-    expect(readTerminalInputWsControlFrame(Buffer.alloc(0))).toBeNull();
+    expect(readTerminalWsControlFrame(null)).toBeNull();
+    expect(readTerminalWsControlFrame(undefined)).toBeNull();
+    expect(readTerminalWsControlFrame(Buffer.alloc(0))).toBeNull();
   });
 
   it('rejects control json that is not object', () => {
     const frame = Buffer.concat([
-      Buffer.from([TERMINAL_INPUT_WS_CONTROL_TAG_JSON]),
+      Buffer.from([TERMINAL_WS_CONTROL_TAG_JSON]),
       Buffer.from('"str"', 'utf8'),
     ]);
-    expect(readTerminalInputWsControlFrame(frame)).toBeNull();
+    expect(readTerminalWsControlFrame(frame)).toBeNull();
   });
 
   it('parses control frame from chunk arrays', () => {
-    const frame = createTerminalInputWsControlFrame({ t: 'bok', v: 1 });
+    const frame = createTerminalWsControlFrame({ t: 'bok', v: 1 });
     const chunks = [frame.subarray(0, 2), frame.subarray(2)];
-    expect(readTerminalInputWsControlFrame(chunks)).toEqual({ t: 'bok', v: 1 });
+    expect(readTerminalWsControlFrame(chunks)).toEqual({ t: 'bok', v: 1 });
   });
 
   it('normalizes buffer passthrough', () => {
     const raw = Buffer.from('abc', 'utf8');
-    const normalized = normalizeTerminalInputWsMessageToBuffer(raw);
+    const normalized = normalizeTerminalWsMessageToBuffer(raw);
     expect(normalized).toBe(raw);
     expect(normalized.toString('utf8')).toBe('abc');
   });
 
   it('normalizes uint8 arrays', () => {
-    const normalized = normalizeTerminalInputWsMessageToBuffer(new Uint8Array([97, 98, 99]));
+    const normalized = normalizeTerminalWsMessageToBuffer(new Uint8Array([97, 98, 99]));
     expect(normalized.toString('utf8')).toBe('abc');
   });
 
   it('normalizes array buffer payloads', () => {
     const source = new Uint8Array([97, 98, 99]).buffer;
-    const normalized = normalizeTerminalInputWsMessageToBuffer(source);
+    const normalized = normalizeTerminalWsMessageToBuffer(source);
     expect(normalized.toString('utf8')).toBe('abc');
   });
 
   it('normalizes chunk array payloads', () => {
-    const normalized = normalizeTerminalInputWsMessageToBuffer([
+    const normalized = normalizeTerminalWsMessageToBuffer([
       Buffer.from('ab', 'utf8'),
       Buffer.from('c', 'utf8'),
     ]);
@@ -88,19 +95,19 @@ describe('terminal input websocket protocol', () => {
   });
 
   it('normalizes text payload from string', () => {
-    expect(normalizeTerminalInputWsMessageToText('\u001b[A')).toBe('\u001b[A');
+    expect(normalizeTerminalWsMessageToText('\u001b[A')).toBe('\u001b[A');
   });
 
   it('normalizes text payload from binary data', () => {
-    expect(normalizeTerminalInputWsMessageToText(Buffer.from('\r', 'utf8'))).toBe('\r');
+    expect(normalizeTerminalWsMessageToText(Buffer.from('\r', 'utf8'))).toBe('\r');
   });
 
   it('parses relative request pathname', () => {
-    expect(parseRequestPathname('/api/terminal/input-ws?x=1')).toBe('/api/terminal/input-ws');
+    expect(parseRequestPathname('/api/terminal/ws?x=1')).toBe('/api/terminal/ws');
   });
 
   it('parses absolute request pathname', () => {
-    expect(parseRequestPathname('http://localhost:3000/api/terminal/input-ws')).toBe('/api/terminal/input-ws');
+    expect(parseRequestPathname('http://localhost:3000/api/terminal/ws')).toBe('/api/terminal/ws');
   });
 
   it('returns empty pathname for non-string request url', () => {

package/server/opencode-proxy.test.js

@@ -0,0 +1,83 @@
+import { afterEach, describe, expect, it } from 'bun:test';
+import express from 'express';
+import path from 'path';
+
+import { registerOpenCodeProxy } from './lib/opencode/proxy.js';
+
+const listen = (app, host = '127.0.0.1') => new Promise((resolve, reject) => {
+  const server = app.listen(0, host, () => resolve(server));
+  server.once('error', reject);
+});
+
+const closeServer = (server) => new Promise((resolve, reject) => {
+  if (!server) {
+    resolve();
+    return;
+  }
+  server.close((error) => {
+    if (error) {
+      reject(error);
+      return;
+    }
+    resolve();
+  });
+});
+
+describe('OpenCode proxy SSE forwarding', () => {
+  let upstreamServer;
+  let proxyServer;
+
+  afterEach(async () => {
+    await closeServer(proxyServer);
+    await closeServer(upstreamServer);
+    proxyServer = undefined;
+    upstreamServer = undefined;
+  });
+
+  it('forwards event streams with nginx-safe headers', async () => {
+    let seenAuthorization = null;
+
+    const upstream = express();
+    upstream.get('/global/event', (req, res) => {
+      seenAuthorization = req.headers.authorization ?? null;
+      res.setHeader('Content-Type', 'text/event-stream; charset=utf-8');
+      res.setHeader('Cache-Control', 'private, max-age=0');
+      res.setHeader('X-Upstream-Test', 'ok');
+      res.write('data: {"ok":true}\n\n');
+      res.end();
+    });
+    upstreamServer = await listen(upstream);
+    const upstreamPort = upstreamServer.address().port;
+
+    const app = express();
+    registerOpenCodeProxy(app, {
+      fs: {},
+      os: {},
+      path,
+      OPEN_CODE_READY_GRACE_MS: 0,
+      getRuntime: () => ({
+        openCodePort: upstreamPort,
+        isOpenCodeReady: true,
+        openCodeNotReadySince: 0,
+        isRestartingOpenCode: false,
+      }),
+      getOpenCodeAuthHeaders: () => ({ Authorization: 'Bearer test-token' }),
+      buildOpenCodeUrl: (requestPath) => `http://127.0.0.1:${upstreamPort}${requestPath}`,
+      ensureOpenCodeApiPrefix: () => {},
+    });
+    proxyServer = await listen(app);
+    const proxyPort = proxyServer.address().port;
+
+    const response = await fetch(`http://127.0.0.1:${proxyPort}/api/global/event`, {
+      headers: { Accept: 'text/event-stream' },
+    });
+
+    expect(response.status).toBe(200);
+    expect(response.headers.get('content-type')).toContain('text/event-stream');
+    expect(response.headers.get('cache-control')).toBe('no-cache');
+    expect(response.headers.get('x-accel-buffering')).toBe('no');
+    expect(response.headers.get('x-upstream-test')).toBe('ok');
+    expect(await response.text()).toBe('data: {"ok":true}\n\n');
+    expect(seenAuthorization).toBe('Bearer test-token');
+  });
+});

package/server/proxy-headers.js

@@ -0,0 +1,61 @@
+const filteredRequestHeaders = new Set([
+  'host',
+  'connection',
+  'content-length',
+  'transfer-encoding',
+  'keep-alive',
+  'te',
+  'trailer',
+  'upgrade',
+  'accept-encoding',
+]);
+
+const filteredResponseHeaders = new Set([
+  'connection',
+  'content-length',
+  'transfer-encoding',
+  'keep-alive',
+  'te',
+  'trailer',
+  'upgrade',
+  'www-authenticate',
+  'content-encoding',
+]);
+
+export const collectForwardProxyHeaders = (requestHeaders, authHeaders = {}) => {
+  const headers = {};
+
+  for (const [key, value] of Object.entries(requestHeaders || {})) {
+    if (!value) continue;
+    const normalizedKey = key.toLowerCase();
+    if (filteredRequestHeaders.has(normalizedKey)) continue;
+    headers[normalizedKey] = Array.isArray(value) ? value.join(', ') : String(value);
+  }
+
+  if (authHeaders.Authorization) {
+    headers.Authorization = authHeaders.Authorization;
+  }
+
+  return headers;
+};
+
+export const shouldForwardProxyResponseHeader = (key) => {
+  if (typeof key !== 'string' || key.trim().length === 0) {
+    return false;
+  }
+
+  return !filteredResponseHeaders.has(key.toLowerCase());
+};
+
+export const applyForwardProxyResponseHeaders = (responseHeaders, response) => {
+  if (!responseHeaders || typeof response?.setHeader !== 'function') {
+    return;
+  }
+
+  for (const [key, value] of responseHeaders.entries()) {
+    if (!shouldForwardProxyResponseHeader(key)) {
+      continue;
+    }
+    response.setHeader(key, value);
+  }
+};

package/server/proxy-headers.test.js

@@ -0,0 +1,58 @@
+import { describe, expect, it } from 'bun:test';
+
+import {
+  applyForwardProxyResponseHeaders,
+  collectForwardProxyHeaders,
+  shouldForwardProxyResponseHeader,
+} from './proxy-headers.js';
+
+describe('OpenCode proxy header handling', () => {
+  it('drops accept-encoding from forwarded request headers', () => {
+    const headers = collectForwardProxyHeaders({
+      accept: 'application/json',
+      'accept-encoding': 'gzip, deflate, br',
+      connection: 'keep-alive',
+    });
+
+    expect(headers.accept).toBe('application/json');
+    expect(headers['accept-encoding']).toBeUndefined();
+  });
+
+  it('drops content-encoding from forwarded response headers', () => {
+    expect(shouldForwardProxyResponseHeader('content-encoding')).toBe(false);
+    expect(shouldForwardProxyResponseHeader('Content-Encoding')).toBe(false);
+  });
+
+  it('drops transfer-encoding from forwarded response headers', () => {
+    expect(shouldForwardProxyResponseHeader('transfer-encoding')).toBe(false);
+    expect(shouldForwardProxyResponseHeader('Transfer-Encoding')).toBe(false);
+  });
+
+  it('still keeps ordinary response headers', () => {
+    expect(shouldForwardProxyResponseHeader('content-type')).toBe(true);
+    expect(shouldForwardProxyResponseHeader('etag')).toBe(true);
+  });
+
+  it('applies upstream response headers to express response without content-encoding', () => {
+    const applied = [];
+    const response = {
+      setHeader(key, value) {
+        applied.push([key, value]);
+      },
+    };
+
+    applyForwardProxyResponseHeaders(
+      new Headers({
+        'content-type': 'application/json',
+        etag: 'W/"abc"',
+        'content-encoding': 'gzip',
+      }),
+      response,
+    );
+
+    expect(applied).toEqual([
+      ['content-type', 'application/json'],
+      ['etag', 'W/"abc"'],
+    ]);
+  });
+});