coding-tool-x 3.9.5-261009 → 3.9.5-261012

package/CHANGELOG.md

@@ -23,6 +23,8 @@
 - **依赖安全升级** - adm-zip 升至 0.6.0（GHSA-xcpc-8h2w-3j85）、js-yaml 升至 4.3.1（GHSA-h67p-54hq-rp68 / GHSA-52cp-r559-cp3m / GHSA-5p4m-2wfm-xmqj）、pm2 升至 7.0.3（GHSA-x5gf-qvw8-r2rm），overrides 同步更新 basic-ftp / qs / systeminformation / js-yaml；`npm audit` 报告归零
 
 ### Fixed
+- **代理连接与内存回收** - 修复各 CLI 请求残留、客户端断开后的上游取消和渠道释放；后台退出时排空代理请求，延长上游空闲超时；OMP 重试取消失败响应，过滤连接保活头，并增加内存压力回收。
+- **CLI 状态和错误子命令** - 修复 `ctx status` 的代理 Driver 状态解析；错误子命令返回非零退出码，不再进入控制面。
 - **Claude / Gemini 原生 wire 兼容** - OpenCode Claude / Gemini 代理、模型探测和测速统一使用 Anthropic Messages 与 Google Generative AI（含 Gemini CLI）原生请求格式、认证头与目标 URL；OMP managed provider 写入 `anthropic-messages` / `google-generative-ai` 标识，避免代理、adapter 与探测各自维护不一致的请求格式
 - **OMP Codex Responses 路径兼容** - managed gateway 将 OMP 原生 `openai-codex-responses` 的 `/codex/responses` 请求映射到 OpenAI-compatible 渠道的 `/v1/responses`，避免 Codex-only 服务返回 HTTP 404
 - **OMP 渠道失败不再冻结** - OMP 动态切换开启后，失败渠道不再进入冻结状态。OMP 网关按请求即时回退其他渠道，冻结会导致短暂故障的渠道在恢复前被排除在后续分配之外

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "coding-tool-x",
-  "version": "3.9.5-261009",
+  "version": "3.9.5-261012",
   "description": "Vibe Coding 增强工作助手 - 智能会话管理、动态渠道切换、全局搜索、实时监控",
   "main": "src/index.js",
   "bin": {

package/src/commands/daemon.js

@@ -299,7 +299,13 @@ async function getProxyStatusEntries({ registry = getPlatformRegistry(), runtime
         entries.push({ platform, state: { status: 'unsupported', ...context }, port: getPlatformPort(platform, config) });
         continue;
       }
-      const state = await Promise.resolve(driver.status());
+      const result = await Promise.resolve(driver.status());
+      // Proxy drivers use the shared Driver contract and wrap successful
+      // service status payloads in { status: 'ok', data }. Keep compatibility
+      // with legacy drivers that return the service payload directly.
+      const state = result && result.status === 'ok'
+        ? (result.data && typeof result.data === 'object' ? result.data : {})
+        : result;
       if (state && typeof state.status === 'string' && state.status !== 'ok') {
         entries.push({ platform, state: { ...state, ...context }, port: getPlatformPort(platform, config) });
       } else {
@@ -508,8 +514,10 @@ function buildStartOptions(port, enableHost, enableHttps) {
     interpreter: 'node',
     windowsHide: true,
     autorestart: true,
-    kill_timeout: 5000,
+    // Let active OMP streams drain before PM2 forcibly terminates the process.
+    kill_timeout: 125000,
     max_memory_restart: '500M',
+    node_args: '--expose-gc',
     env,
     output: path.join(PATHS.logs, STARTUP_LOG_FILE),
     error: path.join(PATHS.logs, STARTUP_LOG_FILE),
@@ -761,9 +769,9 @@ async function handleStatus() {
         console.log(chalk.gray(`  ${label}${chalk.gray('[N/A]  不支持')}`));
         continue;
       }
-      if (state.status === 'failed') {
+      if (state.status && state.status !== 'ok') {
         console.log(chalk.red(`  ${label}${chalk.red('[ERROR] 查询失败')}`) +
-          chalk.gray(` (${state.error || 'unknown error'})`));
+          chalk.gray(` (${state.error || state.status || 'unknown error'})`));
         continue;
       }
       console.log(chalk.gray(`  ${label}`) + (state.running

package/src/index.js

@@ -164,6 +164,11 @@ async function dispatchPlatformCommand(platform, args = [], dependencies = {}) {
   const channel = platform.key;
   const options = dependencies.registry ? { registry: dependencies.registry } : {};
 
+  if (args.length > 1) {
+    reportInvalidCommand('参数', args[1], `ctx ${platform.command || platform.key} ${action}`);
+    return;
+  }
+
   switch (action) {
     case 'start':
       await proxyStart(channel, options);
@@ -178,11 +183,23 @@ async function dispatchPlatformCommand(platform, args = [], dependencies = {}) {
       await proxyStatus(channel, options);
       return;
     default:
-      console.log(chalk.red(`\n[ERROR] 未知操作: ${action}\n`));
-      console.log(chalk.gray('支持的操作: start, stop, restart, status\n'));
+      reportInvalidCommand('操作', action, '支持的操作: start, stop, restart, status');
   }
 }
 
+function reportInvalidCommand(kind, value, usage = '') {
+  console.error(chalk.red(`\n[ERROR] 未知${kind}: ${value}\n`));
+  if (usage) console.error(chalk.gray(`${usage}\n`));
+  process.exitCode = 1;
+}
+
+function validateCommandOptions(command, args, allowedOptions) {
+  const invalidOption = args.find(argument => !allowedOptions.has(argument));
+  if (!invalidOption) return true;
+  reportInvalidCommand('参数', invalidOption, `用法: ${command}`);
+  return false;
+}
+
 let processShutdownPromise = null;
 
 async function stopOwnedOmpGatewayBeforeExit() {
@@ -193,7 +210,7 @@ async function stopOwnedOmpGatewayBeforeExit() {
     } = require('./platforms/drivers/omp/proxy-implementation');
     if (getOmpProxyStatus().running) {
       const preserveManagedMode = process.argv.includes('--daemon');
-      await stopOmpProxyServer({ forceAfterMs: 1500, preserveManagedMode });
+      await stopOmpProxyServer({ forceAfterMs: 120000, preserveManagedMode });
     }
   } catch (error) {
     console.error(chalk.yellow(`[WARN]  OMP 动态网关退出清理失败: ${error.message}`));
@@ -203,12 +220,21 @@ async function stopOwnedOmpGatewayBeforeExit() {
 function shutdownProcess(code = 0, error = null) {
   if (processShutdownPromise) return processShutdownPromise;
   processShutdownPromise = (async () => {
+    try {
+      require('./server/services/memory-reclaimer').stopMemoryReclaimer();
+    } catch (memoryError) {
+      console.error(chalk.yellow(`[WARN] 内存回收器退出清理失败: ${memoryError.message}`));
+    }
     try {
       require('./server/services/native-log-observer').shutdownNativeCliLogObserver();
     } catch (observerError) {
       console.error(chalk.yellow(`[WARN] CLI 原生会话日志退出清理失败: ${observerError.message}`));
     }
-    await stopOwnedOmpGatewayBeforeExit();
+    await Promise.all([
+      stopOwnedOmpGatewayBeforeExit(),
+      require('./server/services/server-shutdown').drainProxyServers({ forceAfterMs: 120000 })
+        .catch(drainError => console.error(`[WARN] Proxy drain failed: ${drainError.message}`))
+    ]);
     eventBus.emitSync('cli:shutdown', {});
     PluginManager.shutdownPlugins();
     try {
@@ -282,6 +308,11 @@ async function main({ menuDependencies } = {}) {
   if (args[0] === 'daemon') {
     const subCommand = args[1] || 'status';
 
+    if (['start', 'stop', 'restart', 'status'].includes(subCommand) && args.length > 2) {
+      reportInvalidCommand('参数', args[2], `ctx daemon ${subCommand}`);
+      return;
+    }
+
     if (subCommand === 'start') {
       await handleStart();
       return finishCli(0);
@@ -314,25 +345,37 @@ async function main({ menuDependencies } = {}) {
       return;
     }
 
-    console.log(chalk.red(`\n[ERROR] 未知 daemon 子命令: ${subCommand}\n`));
-    console.log(chalk.gray('支持的命令: start, stop, restart, status, logs\n'));
+    reportInvalidCommand('daemon 子命令', subCommand, '支持的命令: start, stop, restart, status, logs');
     return;
   }
 
   // reset 命令 - 恢复默认配置
   if (args[0] === 'reset') {
+    if (args.length > 1) {
+      reportInvalidCommand('参数', args[1], '用法: ctx reset');
+      return;
+    }
     await resetConfig();
     return;
   }
 
   // security 命令 - 安全设置
   if (args[0] === 'security') {
-    const { showSecurityHelp, handleSecurityReset } = require('./commands/security');
     const subCommand = args[1] || 'help';
 
+    if (!['reset', 'disable', 'off', 'help'].includes(subCommand)) {
+      reportInvalidCommand('security 子命令', subCommand, '支持的命令: reset, disable, off, help');
+      return;
+    }
+    const { showSecurityHelp, handleSecurityReset } = require('./commands/security');
+
     if (subCommand === 'reset' || subCommand === 'disable' || subCommand === 'off') {
+      if (args.length > 2) {
+        reportInvalidCommand('参数', args[2], `ctx security ${subCommand}`);
+        return;
+      }
       await handleSecurityReset();
-    } else {
+    } else if (subCommand === 'help') {
       showSecurityHelp();
     }
     return;
@@ -340,31 +383,52 @@ async function main({ menuDependencies } = {}) {
 
   // start 命令 - 启动服务（后台）
   if (args[0] === 'start') {
+    if (!validateCommandOptions('ctx start [--host|--hosts] [--https]', args.slice(1), new Set(['--host', '--hosts', '--https']))) return;
     await handleStart();
     return finishCli(0);
   }
 
   // stop 命令 - 停止服务
   if (args[0] === 'stop') {
+    if (args.length > 1) {
+      reportInvalidCommand('参数', args[1], '用法: ctx stop');
+      return;
+    }
     await handleStop();
     return finishCli(0);
   }
 
   // restart 命令 - 重启服务
   if (args[0] === 'restart') {
+    if (!validateCommandOptions('ctx restart [--host|--hosts] [--https]', args.slice(1), new Set(['--host', '--hosts', '--https']))) return;
     await handleRestart();
     return finishCli(0);
   }
 
   // status 命令 - 查看服务状态
   if (args[0] === 'status') {
+    if (args.length > 1) {
+      reportInvalidCommand('参数', args[1], '用法: ctx status');
+      return;
+    }
     await handleStatus();
     return finishCli(0);
   }
 
   // ui 命令 - Web UI 管理
   if (args[0] === 'ui') {
-    const subCommand = args[1];
+    const commandArgs = args.slice(1);
+    const subCommand = commandArgs[0] && !commandArgs[0].startsWith('-') ? commandArgs[0] : null;
+    const optionArgs = subCommand ? commandArgs.slice(1) : commandArgs;
+    const allowedOptions = new Set(['--https', '--host', '--hosts', '--daemon']);
+
+    if (subCommand && !['start', 'stop', 'restart'].includes(subCommand)) {
+      reportInvalidCommand('ui 子命令', subCommand, '支持的命令: start, stop, restart');
+      return;
+    }
+    if (!validateCommandOptions(`ctx ui${subCommand ? ` ${subCommand}` : ''}`, optionArgs,
+      subCommand === 'stop' ? new Set() : allowedOptions)) return;
+
     if (subCommand === 'start') {
       await handleStart();  // UI start 实际上就是启动整个服务
       return finishCli(0);
@@ -440,12 +504,17 @@ async function main({ menuDependencies } = {}) {
 
   // doctor 命令 - 系统诊断
   if (args[0] === 'doctor') {
+    if (args.length > 1) {
+      reportInvalidCommand('参数', args[1], '用法: ctx doctor');
+      return;
+    }
     await handleDoctor();
     return;
   }
 
   // update 命令 - 检查并更新到最新版本
   if (args[0] === 'update') {
+    if (!validateCommandOptions('ctx update [--check]', args.slice(1), new Set(['--check']))) return;
     const checkOnly = args.includes('--check');
     await handleUpdate({ checkOnly });
     return;
@@ -453,6 +522,10 @@ async function main({ menuDependencies } = {}) {
 
   // port 命令 - 配置端口
   if (args[0] === 'port') {
+    if (args.length > 1) {
+      reportInvalidCommand('参数', args[1], '用法: ctx port');
+      return;
+    }
     const { handlePortConfig } = require('./commands/port-config');
     await handlePortConfig();
     return;
@@ -460,9 +533,18 @@ async function main({ menuDependencies } = {}) {
 
   // 代理命令
   if (args[0] === 'proxy') {
-    const { handleProxyStart, handleProxyStop, handleProxyStatus } = require('./commands/proxy');
     const subCommand = args[1] || 'start';
 
+    if (!['start', 'stop', 'status'].includes(subCommand)) {
+      reportInvalidCommand('proxy 子命令', subCommand, '支持的命令: start, stop, status');
+      return;
+    }
+    if (args.length > 2) {
+      reportInvalidCommand('参数', args[2], `ctx proxy ${subCommand}`);
+      return;
+    }
+    const { handleProxyStart, handleProxyStop, handleProxyStatus } = require('./commands/proxy');
+
     switch (subCommand) {
       case 'start':
         await handleProxyStart();
@@ -476,10 +558,6 @@ async function main({ menuDependencies } = {}) {
         handleProxyStatus();
         return;
 
-      default:
-        // 默认执行 start
-        await handleProxyStart();
-        return;
     }
   }
 
@@ -508,6 +586,12 @@ async function main({ menuDependencies } = {}) {
     return;
   }
 
+  if (args.length > 0) {
+    reportInvalidCommand('命令', args[0], '运行 ctx --help 查看可用命令');
+    PluginManager.shutdownPlugins();
+    return;
+  }
+
   while (true) {
     // 显示主菜单
     const { showMainMenu } = require('./ui/menu');

package/src/platforms/drivers/claude/openai-gateway.js

@@ -7,7 +7,7 @@ const { createDecodedStream } = require('../../../server/services/response-decod
 const { parseNonStreamingUsage } = require('../../../shared/response-usage-parser');
 const { convertClaudeToOpenCodePayload } = require('../opencode/gateway-converter');
 
-const REQUEST_TIMEOUT_MS = 120000;
+const { PROXY_IDLE_TIMEOUT_MS: REQUEST_TIMEOUT_MS } = require('../../../server/services/server-shutdown');
 
 function getRequestPathname(urlPath = '') {
   try {

package/src/platforms/drivers/claude/proxy-implementation.js

@@ -19,14 +19,15 @@ const {
 const { persistProxyRequestSnapshot, persistClaudeRequestTemplate } = require('../../../server/services/request-logger');
 const { redirectModel, normalizeGatewaySourceType } = require('../../../shared/proxy-utils');
 const { handleClaudeOpenAiGatewayRequest } = require('./openai-gateway');
-const { attachServerShutdownHandling, expediteServerShutdown } = require('../../../server/services/server-shutdown');
+const { bindProxyRequest, prepareProxyResponse } = require('../../../shared/proxy-transport');
+const { attachServerShutdownHandling, expediteServerShutdown, PROXY_IDLE_TIMEOUT_MS } = require('../../../server/services/server-shutdown');
 
 let proxyServer = null;
 let proxyApp = null;
 let currentPort = null;
 
 // 用于存储每个请求的元数据（用于 WebSocket 日志）
-const requestMetadata = new Map();
+let requestMetadata = new WeakMap();
 
 // 用于缓存已打印过的模型重定向规则，避免重复打印
 // 格式: { channelId: { "originalModel": "redirectedModel", ... } }
@@ -35,7 +36,7 @@ const printedRedirectCache = new Map();
 const jsonBodyParser = express.json({
   limit: '100mb',
   verify: (req, res, buf) => {
-    req.rawBody = Buffer.from(buf);
+    req.rawBody = buf;
   }
 });
 
@@ -174,6 +175,7 @@ async function startProxyServer(options = {}) {
     const proxy = httpProxy.createProxyServer({});
 
     proxy.on('proxyReq', (proxyReq, req, res) => {
+      bindProxyRequest(proxyReq, res);
       const selectedChannel = req.selectedChannel;
       if (selectedChannel) {
         const requestId = `${Date.now()}-${Math.random()}`;
@@ -238,9 +240,10 @@ async function startProxyServer(options = {}) {
         };
 
         req.__releaseChannel = release;
-
+        res.on('finish', release);
         res.on('close', release);
         res.on('error', release);
+        if (res.destroyed || res.writableEnded) { release(); return; }
 
         const effectiveKey = getEffectiveApiKey(channel);
         if (!effectiveKey) {
@@ -306,8 +309,8 @@ async function startProxyServer(options = {}) {
         const proxyOptions = {
           target: channel.baseUrl,
           changeOrigin: true,
-          proxyTimeout: 120000,  // 代理连接超时 2 分钟
-          timeout: 120000        // 请求超时 2 分钟
+          proxyTimeout: PROXY_IDLE_TIMEOUT_MS,  // Allow long reasoning gaps without an unbounded upstream wait
+          timeout: 0            // The upstream timeout bounds idle waits; streaming clients may pause
         };
 
         if (channel.proxyUrl) {
@@ -329,6 +332,7 @@ async function startProxyServer(options = {}) {
           }
         });
       } catch (error) {
+        req.__releaseChannel?.();
         console.error('Channel allocation error:', error);
         if (!res.headersSent) {
           res.status(503).json({
@@ -341,6 +345,7 @@ async function startProxyServer(options = {}) {
 
     // 代理响应只负责维护传输健康状态；实时日志和 usage 来自 CLI 原生日志。
     proxy.on('proxyRes', (proxyRes, req, res) => {
+      prepareProxyResponse(proxyRes, res);
       const metadata = requestMetadata.get(req);
       if (!metadata) return;
 
@@ -425,9 +430,9 @@ async function stopProxyServer(options = {}) {
     return { success: true, message: 'Proxy server not running' };
   }
 
-  requestMetadata.clear();
+  requestMetadata = new WeakMap();
 
-  const shutdownTimer = expediteServerShutdown(proxyServer);
+  const shutdownTimer = expediteServerShutdown(proxyServer, { forceAfterMs: options.forceAfterMs });
 
   return new Promise((resolve) => {
     proxyServer.close(() => {

package/src/platforms/drivers/codex/proxy-implementation.js

@@ -15,14 +15,15 @@ const {
   isChatCompletionsPath,
   ensureOpenAiStreamUsage
 } = require('../../../shared/proxy-utils');
-const { attachServerShutdownHandling, expediteServerShutdown } = require('../../../server/services/server-shutdown');
+const { bindProxyRequest, prepareProxyResponse } = require('../../../shared/proxy-transport');
+const { attachServerShutdownHandling, expediteServerShutdown, PROXY_IDLE_TIMEOUT_MS } = require('../../../server/services/server-shutdown');
 
 let proxyServer = null;
 let proxyApp = null;
 let currentPort = null;
 
 // 用于存储每个请求的元数据
-const requestMetadata = new Map();
+let requestMetadata = new WeakMap();
 
 // 用于缓存已打印过的模型重定向规则，避免重复打印
 // 格式: { channelId: { "originalModel": "redirectedModel", ... } }
@@ -37,7 +38,7 @@ const resolveCodexTarget = resolveTargetUrl;
 const jsonBodyParser = express.json({
   limit: '100mb',
   verify: (req, res, buf) => {
-    req.rawBody = Buffer.from(buf);
+    req.rawBody = buf;
   }
 });
 
@@ -77,7 +78,8 @@ async function startCodexProxyServer(options = {}) {
 
     const proxy = httpProxy.createProxyServer({});
 
-    proxy.on('proxyReq', (proxyReq, req) => {
+    proxy.on('proxyReq', (proxyReq, req, res) => {
+      bindProxyRequest(proxyReq, res);
       const activeChannel = req.selectedChannel;
       if (!activeChannel) return;
 
@@ -127,8 +129,11 @@ async function startCodexProxyServer(options = {}) {
           };
         })();
 
+        req.__releaseChannel = release;
+        res.on('finish', release);
         res.on('close', release);
         res.on('error', release);
+        if (res.destroyed || res.writableEnded) { release(); return; }
 
         broadcastSchedulerState('codex', getSchedulerState('codex'));
 
@@ -200,8 +205,8 @@ async function startCodexProxyServer(options = {}) {
         proxy.web(req, res, {
           target,
           changeOrigin: true,
-          proxyTimeout: 120000,  // 代理连接超时 2 分钟
-          timeout: 120000        // 请求超时 2 分钟
+          proxyTimeout: PROXY_IDLE_TIMEOUT_MS,  // Allow long reasoning gaps without an unbounded upstream wait
+          timeout: 0            // The upstream timeout bounds idle waits; streaming clients may pause
         }, (err) => {
           release();
           if (err) {
@@ -218,6 +223,7 @@ async function startCodexProxyServer(options = {}) {
           }
         });
       } catch (error) {
+        req.__releaseChannel?.();
         console.error('Codex channel allocation error:', error);
         if (!res.headersSent) {
           res.status(503).json({
@@ -232,6 +238,7 @@ async function startCodexProxyServer(options = {}) {
 
     // 代理响应只负责维护传输健康状态；实时日志和 usage 来自 CLI 原生日志。
     proxy.on('proxyRes', (proxyRes, req, res) => {
+      prepareProxyResponse(proxyRes, res);
       const metadata = requestMetadata.get(req);
       if (!metadata) return;
 
@@ -277,8 +284,7 @@ async function startCodexProxyServer(options = {}) {
       console.error('Codex proxy error:', err);
       if (req && req.selectedChannel) {
         recordFailure(req.selectedChannel.id, 'codex', err);
-        releaseChannel(req.selectedChannel.id, 'codex');
-        broadcastSchedulerState('codex', getSchedulerState('codex'));
+        req.__releaseChannel?.();
       }
       if (res && !res.headersSent) {
         res.status(502).json({
@@ -331,9 +337,9 @@ async function stopCodexProxyServer(options = {}) {
     return { success: true, message: 'Codex proxy server not running' };
   }
 
-  requestMetadata.clear();
+  requestMetadata = new WeakMap();
 
-  const shutdownTimer = expediteServerShutdown(proxyServer);
+  const shutdownTimer = expediteServerShutdown(proxyServer, { forceAfterMs: options.forceAfterMs });
 
   return new Promise((resolve) => {
     proxyServer.close(() => {

package/src/platforms/drivers/dsh/proxy-implementation.js

@@ -20,16 +20,17 @@ const {
 const { persistProxyRequestSnapshot } = require('../../../server/services/request-logger');
 const { redirectModel, resolveTargetUrl, isChatCompletionsPath, ensureOpenAiStreamUsage } = require('../../../shared/proxy-utils');
 const { saveProxyStartTime, clearProxyStartTime, getProxyStartTime, getProxyRuntime } = require('../../../server/services/proxy-runtime');
-const { attachServerShutdownHandling, expediteServerShutdown } = require('../../../server/services/server-shutdown');
+const { bindProxyRequest, prepareProxyResponse } = require('../../../shared/proxy-transport');
+const { attachServerShutdownHandling, expediteServerShutdown, PROXY_IDLE_TIMEOUT_MS } = require('../../../server/services/server-shutdown');
 
 let proxyServer = null;
 let currentPort = null;
-const requestMetadata = new Map();
+let requestMetadata = new WeakMap();
 
 const jsonBodyParser = express.json({
   limit: '100mb',
   verify: (req, _res, buffer) => {
-    req.rawBody = Buffer.from(buffer);
+    req.rawBody = buffer;
   }
 });
 
@@ -84,8 +85,11 @@ async function startDshProxyServer(options = {}) {
       });
       req.selectedChannel = channel;
       release = releaseOnce(channel);
+      req.__releaseChannel = release;
+      res.on('finish', release);
       res.on('close', release);
       res.on('error', release);
+      if (res.destroyed || res.writableEnded) { release(); return; }
       broadcastSchedulerState('dsh', getSchedulerState('dsh'));
 
       const apiKey = getEffectiveApiKey(channel);
@@ -119,8 +123,8 @@ async function startDshProxyServer(options = {}) {
       proxy.web(req, res, {
         target: resolveTargetUrl(channel.baseUrl, req.url),
         changeOrigin: true,
-        proxyTimeout: 120000,
-        timeout: 120000
+        proxyTimeout: PROXY_IDLE_TIMEOUT_MS,
+        timeout: 0
       }, error => {
         release?.();
         if (!error) return;
@@ -137,7 +141,8 @@ async function startDshProxyServer(options = {}) {
     }
   });
 
-  proxy.on('proxyReq', (proxyReq, req) => {
+  proxy.on('proxyReq', (proxyReq, req, res) => {
+    bindProxyRequest(proxyReq, res);
     const channel = req.selectedChannel;
     if (!channel) return;
     const metadata = {
@@ -161,22 +166,32 @@ async function startDshProxyServer(options = {}) {
   });
 
   proxy.on('proxyRes', (proxyRes, req, res) => {
+    prepareProxyResponse(proxyRes, res);
     const metadata = requestMetadata.get(req);
     if (!metadata) return;
-    if (Number(proxyRes.statusCode) >= 400) {
-      recordFailure(metadata.channelId, 'dsh', new Error(`DSH upstream HTTP ${proxyRes.statusCode}`));
-    } else {
-      recordSuccess(metadata.channelId, 'dsh');
-    }
-    requestMetadata.delete(req);
-    res?.on('close', () => requestMetadata.delete(req));
+    let completed = false;
+    const finish = error => {
+      if (completed) return;
+      completed = true;
+      requestMetadata.delete(req);
+      if (error || Number(proxyRes.statusCode) >= 400) {
+        recordFailure(metadata.channelId, 'dsh', error || new Error(`DSH upstream HTTP ${proxyRes.statusCode}`));
+      } else {
+        recordSuccess(metadata.channelId, 'dsh');
+      }
+    };
+    proxyRes.once('end', () => finish());
+    proxyRes.once('error', finish);
+    proxyRes.once('close', () => {
+      if (!completed) finish(new Error('DSH upstream response closed early'));
+    });
+    res?.once('close', () => requestMetadata.delete(req));
   });
 
   proxy.on('error', (error, req, res) => {
     if (req?.selectedChannel) {
       recordFailure(req.selectedChannel.id, 'dsh', error);
-      releaseChannel(req.selectedChannel.id, 'dsh');
-      broadcastSchedulerState('dsh', getSchedulerState('dsh'));
+      req.__releaseChannel?.();
     }
     if (res && !res.headersSent) res.status(502).json({ error: { message: `Proxy error: ${error.message}`, type: 'proxy_error' } });
   });
@@ -213,10 +228,10 @@ async function startDshProxyServer(options = {}) {
 async function stopDshProxyServer(options = {}) {
   const clearStartTime = options.clearStartTime !== false;
   const stoppedPort = currentPort;
-  requestMetadata.clear();
+  requestMetadata = new WeakMap();
 
   if (proxyServer) {
-    const shutdownTimer = expediteServerShutdown(proxyServer);
+    const shutdownTimer = expediteServerShutdown(proxyServer, { forceAfterMs: options.forceAfterMs });
     await new Promise(resolve => proxyServer.close(resolve));
     if (shutdownTimer) clearTimeout(shutdownTimer);
     proxyServer = null;

package/src/platforms/drivers/gemini/proxy-implementation.js

@@ -13,14 +13,15 @@ const {
 } = require('./channels-implementation');
 const { persistProxyRequestSnapshot } = require('../../../server/services/request-logger');
 const { redirectModel: redirectModelBase, resolveTargetUrl } = require('../../../shared/proxy-utils');
-const { attachServerShutdownHandling, expediteServerShutdown } = require('../../../server/services/server-shutdown');
+const { bindProxyRequest, prepareProxyResponse } = require('../../../shared/proxy-transport');
+const { attachServerShutdownHandling, expediteServerShutdown, PROXY_IDLE_TIMEOUT_MS } = require('../../../server/services/server-shutdown');
 
 let proxyServer = null;
 let proxyApp = null;
 let currentPort = null;
 
 // 用于存储每个请求的元数据
-const requestMetadata = new Map();
+let requestMetadata = new WeakMap();
 
 // 用于缓存已打印过的模型重定向规则，避免重复打印
 // 格式: { channelId: { "originalModel": "redirectedModel", ... } }
@@ -30,7 +31,7 @@ const printedGeminiRedirectCache = new Map();
 const jsonBodyParser = express.json({
   limit: '100mb',
   verify: (req, res, buf) => {
-    req.rawBody = Buffer.from(buf);
+    req.rawBody = buf;
   }
 });
 
@@ -198,7 +199,8 @@ async function startGeminiProxyServer(options = {}) {
 
     const proxy = httpProxy.createProxyServer({});
 
-    proxy.on('proxyReq', (proxyReq, req) => {
+    proxy.on('proxyReq', (proxyReq, req, res) => {
+      bindProxyRequest(proxyReq, res);
       const activeChannel = req.selectedChannel;
       if (!activeChannel) return;
 
@@ -255,8 +257,11 @@ async function startGeminiProxyServer(options = {}) {
           };
         })();
 
+        req.__releaseChannel = release;
+        res.on('finish', release);
         res.on('close', release);
         res.on('error', release);
+        if (res.destroyed || res.writableEnded) { release(); return; }
 
         broadcastSchedulerState('gemini', getSchedulerState('gemini'));
 
@@ -335,8 +340,8 @@ async function startGeminiProxyServer(options = {}) {
         proxy.web(req, res, {
           target,
           changeOrigin: true,
-          proxyTimeout: 120000,  // 代理连接超时 2 分钟
-          timeout: 120000        // 请求超时 2 分钟
+          proxyTimeout: PROXY_IDLE_TIMEOUT_MS,  // Allow long reasoning gaps without an unbounded upstream wait
+          timeout: 0            // The upstream timeout bounds idle waits; streaming clients may pause
         }, (err) => {
           release();
           if (err) {
@@ -353,6 +358,7 @@ async function startGeminiProxyServer(options = {}) {
           }
         });
       } catch (error) {
+        req.__releaseChannel?.();
         console.error('Gemini channel allocation error:', error);
         if (!res.headersSent) {
           res.status(503).json({
@@ -367,6 +373,7 @@ async function startGeminiProxyServer(options = {}) {
 
     // 代理响应只负责维护传输健康状态；实时日志和 usage 来自 CLI 原生日志。
     proxy.on('proxyRes', (proxyRes, req, res) => {
+      prepareProxyResponse(proxyRes, res);
       const metadata = requestMetadata.get(req);
       if (!metadata) return;
 
@@ -403,8 +410,7 @@ async function startGeminiProxyServer(options = {}) {
       console.error('Gemini proxy error:', err);
       if (req && req.selectedChannel) {
         recordFailure(req.selectedChannel.id, 'gemini', err);
-        releaseChannel(req.selectedChannel.id, 'gemini');
-        broadcastSchedulerState('gemini', getSchedulerState('gemini'));
+        req.__releaseChannel?.();
       }
       if (res && !res.headersSent) {
         res.status(502).json({
@@ -457,9 +463,9 @@ async function stopGeminiProxyServer(options = {}) {
     return { success: true, message: 'Gemini proxy server not running' };
   }
 
-  requestMetadata.clear();
+  requestMetadata = new WeakMap();
 
-  const shutdownTimer = expediteServerShutdown(proxyServer);
+  const shutdownTimer = expediteServerShutdown(proxyServer, { forceAfterMs: options.forceAfterMs });
 
   return new Promise((resolve) => {
     proxyServer.close(() => {

package/src/platforms/drivers/omp/gateway.js

@@ -1,6 +1,7 @@
 'use strict';
 
 const crypto = require('crypto');
+const { downstreamHeaders } = require('../../../shared/proxy-transport');
 const http = require('http');
 const https = require('https');
 const httpProxy = require('http-proxy');
@@ -118,12 +119,20 @@ function readRequestBody(req) {
     const chunks = [];
     let size = 0;
     let settled = false;
+    const cleanup = () => {
+      chunks.length = 0;
+      req.removeListener('data', onData);
+      req.removeListener('end', onEnd);
+      req.removeListener('error', fail);
+      req.removeListener('aborted', onAborted);
+    };
     const fail = (error) => {
       if (settled) return;
       settled = true;
+      cleanup();
       reject(error);
     };
-    req.on('data', (chunk) => {
+    const onData = (chunk) => {
       if (settled) return;
       size += chunk.length;
       if (size > MAX_REQUEST_BYTES) {
@@ -132,14 +141,19 @@ function readRequestBody(req) {
         return;
       }
       chunks.push(chunk);
-    });
-    req.on('end', () => {
+    };
+    const onEnd = () => {
       if (settled) return;
       settled = true;
-      resolve(Buffer.concat(chunks));
-    });
+      const body = Buffer.concat(chunks, size);
+      cleanup();
+      resolve(body);
+    };
+    const onAborted = () => fail(new Error('Client aborted request'));
+    req.on('data', onData);
+    req.on('end', onEnd);
     req.on('error', fail);
-    req.on('aborted', () => fail(new Error('Client aborted request')));
+    req.on('aborted', onAborted);
   });
 }
 
@@ -184,6 +198,7 @@ function writeJson(res, statusCode, payload) {
   res.end(body);
 }
 
+
 function redactSensitiveQuery(path) {
   const url = new URL(String(path || '/'), 'http://127.0.0.1');
   for (const key of [...url.searchParams.keys()]) {
@@ -330,8 +345,13 @@ function createOmpGateway(options = {}) {
         upstreamResponse = response;
         activeUpstreams.delete(upstreamRequest);
         activeUpstreams.add(response);
+        // Install error handling before resolving: discarded retry responses
+        // must never raise an unhandled stream error and terminate the daemon.
+        response.on('error', () => {});
         response.once('close', () => {
+          activeUpstreams.delete(response);
           signal?.removeEventListener('abort', abortUpstream);
+          releaseOnce();
         });
         const statusCode = response.statusCode || 502;
         resolve({
@@ -387,8 +407,7 @@ function createOmpGateway(options = {}) {
       try {
         const result = await forwardAttempt(req, route, channel, body, signal);
         if (attempt === 0 && RETRYABLE_STATUS.has(result.statusCode)) {
-          result.response.once('close', () => activeUpstreams.delete(result.response));
-          result.response.resume();
+          result.response.destroy();
           result.release();
           onFailure(channel.id, 'omp');
           lastError = Object.assign(new Error(`OMP upstream returned HTTP ${result.statusCode}`), {
@@ -397,7 +416,7 @@ function createOmpGateway(options = {}) {
           continue;
         }
 
-        res.writeHead(result.statusCode, result.response.headers);
+        res.writeHead(result.statusCode, downstreamHeaders(result.response.headers));
         await new Promise((resolve) => {
           let completed = false;
           const finish = (error) => {
@@ -413,7 +432,12 @@ function createOmpGateway(options = {}) {
             resolve();
           };
           result.response.once('end', () => finish());
-          result.response.once('close', () => finish(new Error('OMP upstream response closed early')));
+          result.response.once('close', () => {
+            if (completed) return;
+            const error = new Error('OMP upstream response closed early');
+            if (!res.destroyed) res.destroy(error);
+            finish(error);
+          });
           result.response.once('error', (error) => {
             if (!res.destroyed) res.destroy(error);
             finish(error);
@@ -640,7 +664,7 @@ function createOmpGateway(options = {}) {
       handleRequest(req, res).catch((error) => {
         writeJson(res, 500, { error: error.message || 'OMP gateway request failed' });
       });
-    }));
+    }), { drainOnExit: false });
     server.on('upgrade', (req, socket, head) => {
       handleUpgrade(req, socket, head).catch((error) => {
         rejectUpgrade(socket, 503, error.message || 'OMP websocket proxy failed');

package/src/platforms/drivers/opencode/proxy-implementation.js

@@ -22,7 +22,8 @@ const {
   resolveTargetUrl,
   ensureOpenAiStreamUsage
 } = require('../../../shared/proxy-utils');
-const { attachServerShutdownHandling, expediteServerShutdown } = require('../../../server/services/server-shutdown');
+const { bindProxyRequest, prepareProxyResponse } = require('../../../shared/proxy-transport');
+const { attachServerShutdownHandling, expediteServerShutdown, PROXY_IDLE_TIMEOUT_MS } = require('../../../server/services/server-shutdown');
 const { buildCodexTargetUrl, createCodexRequest } = require('../codex/wire');
 const { createClaudeRequest, buildClaudeTargetUrl, buildClaudeCountTokensTargetUrl, buildClaudeCountTokensHeaders } = require('../claude/wire');
 const { createGeminiRequest, buildGeminiTargetUrl, shouldUseGeminiCliFormat } = require('../gemini/wire');
@@ -32,7 +33,7 @@ let proxyApp = null;
 let currentPort = null;
 
 // 用于存储每个请求的元数据
-const requestMetadata = new Map();
+let requestMetadata = new WeakMap();
 
 // 用于缓存已打印过的模型重定向规则，避免重复打印
 // 格式: { channelId: { "originalModel": "redirectedModel", ... } }
@@ -52,7 +53,7 @@ const resolveOpenCodeTarget = resolveTargetUrl;
 const jsonBodyParser = express.json({
   limit: '100mb',
   verify: (req, res, buf) => {
-    req.rawBody = Buffer.from(buf);
+    req.rawBody = buf;
   }
 });
 
@@ -350,7 +351,7 @@ function collectHttpResponseBody(res) {
   });
 }
 
-function postJson(url, headers, payload, timeoutMs = 120000) {
+function postJson(url, headers, payload, timeoutMs = PROXY_IDLE_TIMEOUT_MS) {
   return new Promise((resolve, reject) => {
     const target = new URL(url);
     const isHttps = target.protocol === 'https:';
@@ -388,7 +389,7 @@ function postJson(url, headers, payload, timeoutMs = 120000) {
   });
 }
 
-function postJsonStream(url, headers, payload, timeoutMs = 120000) {
+function postJsonStream(url, headers, payload, timeoutMs = PROXY_IDLE_TIMEOUT_MS) {
   return new Promise((resolve, reject) => {
     const target = new URL(url);
     const isHttps = target.protocol === 'https:';
@@ -3069,7 +3070,8 @@ async function startOpenCodeProxyServer(options = {}) {
 
     const proxy = httpProxy.createProxyServer({});
 
-    proxy.on('proxyReq', (proxyReq, req) => {
+    proxy.on('proxyReq', (proxyReq, req, res) => {
+      bindProxyRequest(proxyReq, res);
       const activeChannel = req.selectedChannel;
       if (!activeChannel) return;
 
@@ -3128,11 +3130,30 @@ async function startOpenCodeProxyServer(options = {}) {
         const channel = await allocateChannel({ source: 'opencode', enableSessionBinding: false });
         req.selectedChannel = channel;
 
+        const release = (() => {
+          let released = false;
+          return () => {
+            if (released) return;
+            released = true;
+            releaseChannel(channel.id, 'opencode');
+            broadcastSchedulerState('opencode', getSchedulerState('opencode'));
+          };
+        })();
+
+        req.__releaseChannel = release;
+        res.on('finish', release);
+        res.on('close', release);
+        res.on('error', release);
+
+        broadcastSchedulerState('opencode', getSchedulerState('opencode'));
+
+        if (res.destroyed || res.writableEnded) { release(); return; }
+
         // 检查 API key 是否有效
         const effectiveKey = await getEffectiveApiKey(channel);
+        if (res.destroyed || res.writableEnded) { release(); return; }
         if (!effectiveKey) {
-          releaseChannel(channel.id, 'opencode');
-          broadcastSchedulerState('opencode', getSchedulerState('opencode'));
+          release();
           return res.status(401).json({
             error: {
               message: 'API key not configured or expired. Please update your channel key.',
@@ -3195,21 +3216,6 @@ async function startOpenCodeProxyServer(options = {}) {
           req.rawBody = Buffer.from(JSON.stringify(req.body));
         }
 
-        const release = (() => {
-          let released = false;
-          return () => {
-            if (released) return;
-            released = true;
-            releaseChannel(channel.id, 'opencode');
-            broadcastSchedulerState('opencode', getSchedulerState('opencode'));
-          };
-        })();
-
-        res.on('close', release);
-        res.on('error', release);
-
-        broadcastSchedulerState('opencode', getSchedulerState('opencode'));
-
         const gatewaySourceType = normalizeGatewaySourceType(channel);
         if (gatewaySourceType === 'codex') {
           const handled = await handleCodexGatewayRequest(req, res, channel, effectiveKey);
@@ -3235,8 +3241,8 @@ async function startOpenCodeProxyServer(options = {}) {
         proxy.web(req, res, {
           target,
           changeOrigin: true,
-          proxyTimeout: 120000,  // 代理连接超时 2 分钟
-          timeout: 120000        // 请求超时 2 分钟
+          proxyTimeout: PROXY_IDLE_TIMEOUT_MS,  // Allow long reasoning gaps without an unbounded upstream wait
+          timeout: 0            // The upstream timeout bounds idle waits; streaming clients may pause
         }, (err) => {
           release();
           if (err) {
@@ -3253,6 +3259,7 @@ async function startOpenCodeProxyServer(options = {}) {
           }
         });
       } catch (error) {
+        req.__releaseChannel?.();
         console.error('OpenCode channel allocation error:', error);
         if (!res.headersSent) {
           res.status(503).json({
@@ -3267,6 +3274,7 @@ async function startOpenCodeProxyServer(options = {}) {
 
     // 代理响应只负责维护传输健康状态；实时日志和 usage 来自 CLI 原生日志。
     proxy.on('proxyRes', (proxyRes, req, res) => {
+      prepareProxyResponse(proxyRes, res);
       const metadata = requestMetadata.get(req);
       if (!metadata) return;
 
@@ -3303,8 +3311,7 @@ async function startOpenCodeProxyServer(options = {}) {
       console.error('OpenCode proxy error:', err);
       if (req && req.selectedChannel) {
         recordFailure(req.selectedChannel.id, 'opencode', err);
-        releaseChannel(req.selectedChannel.id, 'opencode');
-        broadcastSchedulerState('opencode', getSchedulerState('opencode'));
+        req.__releaseChannel?.();
       }
       if (res && !res.headersSent) {
         res.status(502).json({
@@ -3359,9 +3366,9 @@ async function stopOpenCodeProxyServer(options = {}) {
     return { success: true, message: 'OpenCode proxy server not running' };
   }
 
-  requestMetadata.clear();
+  requestMetadata = new WeakMap();
 
-  const shutdownTimer = expediteServerShutdown(proxyServer);
+  const shutdownTimer = expediteServerShutdown(proxyServer, { forceAfterMs: options.forceAfterMs });
 
   return new Promise((resolve) => {
     proxyServer.close(() => {

package/src/server/index.js

@@ -24,6 +24,7 @@ const {
   createSameOriginGuard
 } = require('./services/network-access');
 const { createApiRequestLogger } = require('./services/request-logger');
+const { startMemoryReclaimer, trackMemoryActivity } = require('./services/memory-reclaimer');
 const { inspectWebBuildState, ensureWebDistReady } = require('./services/web-build');
 const { ensureHttpsCredentials } = require('./services/https-cert');
 const { scheduleSessionHistoryMaintenance } = require('./services/session-history-maintenance');
@@ -197,6 +198,7 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
   const allowRemoteMutation = isRemoteMutationAllowedByEnv(process.env);
 
   // Middleware
+  app.use(trackMemoryActivity);
   app.use(express.json({ limit: '100mb' }));
   app.use(express.urlencoded({ limit: '100mb', extended: true }));
 
@@ -368,6 +370,7 @@ async function startServer(port, host = '127.0.0.1', options = {}) {
     traceStartupMemory('proxy-restore-complete');
     await performStartupHealthCheck({ config });
     traceStartupMemory('health-check-complete');
+    startMemoryReclaimer();
     return server;
   } finally {
     try {

package/src/server/services/memory-reclaimer.js

@@ -0,0 +1,88 @@
+'use strict';
+
+const MIB = 1024 * 1024;
+const CHECK_INTERVAL_MS = 5_000;
+const MIN_IDLE_MS = 30_000;
+const GC_COOLDOWN_MS = 5 * 60_000;
+const RSS_PRESSURE_BYTES = 380 * MIB;
+const HEAP_PRESSURE_BYTES = 256 * MIB;
+const URGENT_RSS_BYTES = 450 * MIB;
+const URGENT_GC_COOLDOWN_MS = 30_000;
+
+let timer = null;
+let activeRequests = 0;
+let lastActivityAt = Date.now();
+let lastCollectionAt = 0;
+
+function trackMemoryActivity(_req, res, next) {
+  if (typeof global.gc !== 'function') {
+    if (typeof next === 'function') next();
+    return;
+  }
+
+  activeRequests += 1;
+  lastActivityAt = Date.now();
+  let completed = false;
+  const complete = () => {
+    if (completed) return;
+    completed = true;
+    activeRequests = Math.max(0, activeRequests - 1);
+    lastActivityAt = Date.now();
+  };
+
+  // HTTP completion ends a request; upgraded sockets stay active until close.
+  if (typeof res.writeHead === 'function') res.once('finish', complete);
+  res.once('close', complete);
+  if (typeof next === 'function') next();
+}
+
+function collectIfIdleAndUnderPressure() {
+  if (activeRequests > 0) return;
+
+  const before = process.memoryUsage();
+  const urgent = before.rss >= URGENT_RSS_BYTES;
+  if (!urgent && Date.now() - lastActivityAt < MIN_IDLE_MS) return;
+  if (before.rss < RSS_PRESSURE_BYTES && before.heapUsed < HEAP_PRESSURE_BYTES) return;
+
+  const now = Date.now();
+  const cooldown = urgent ? URGENT_GC_COOLDOWN_MS : GC_COOLDOWN_MS;
+  if (now - lastCollectionAt < cooldown) return;
+  lastCollectionAt = now;
+
+  try {
+    global.gc();
+    if (process.env.CC_TOOL_MEMORY_TRACE === '1') {
+      const after = process.memoryUsage();
+      console.log(`[MEM] idle-gc ${JSON.stringify({
+        pid: process.pid,
+        urgent,
+        rssBefore: before.rss,
+        rssAfter: after.rss,
+        heapUsedBefore: before.heapUsed,
+        heapUsedAfter: after.heapUsed
+      })}`);
+    }
+  } catch (error) {
+    console.warn(`[MEM] Idle memory collection failed: ${error.message}`);
+  }
+}
+
+function startMemoryReclaimer() {
+  if (timer || typeof global.gc !== 'function') return false;
+  timer = setInterval(collectIfIdleAndUnderPressure, CHECK_INTERVAL_MS);
+  if (typeof timer.unref === 'function') timer.unref();
+  return true;
+}
+
+function stopMemoryReclaimer() {
+  if (timer) clearInterval(timer);
+  timer = null;
+  activeRequests = 0;
+  lastActivityAt = Date.now();
+}
+
+module.exports = {
+  startMemoryReclaimer,
+  stopMemoryReclaimer,
+  trackMemoryActivity
+};

package/src/server/services/server-shutdown.js

@@ -1,4 +1,7 @@
 const SOCKET_TRACKER = Symbol('ccTool.socketTracker');
+const { trackMemoryActivity } = require('./memory-reclaimer');
+const proxyServers = new Set();
+const PROXY_IDLE_TIMEOUT_MS = 10 * 60_000;
 
 function attachServerShutdownHandling(server, options = {}) {
   if (!server || server[SOCKET_TRACKER]) {
@@ -6,6 +9,10 @@ function attachServerShutdownHandling(server, options = {}) {
   }
 
   const sockets = new Set();
+  // Proxy servers share the process with the UI; streaming requests must also
+  // prevent idle memory collection until their response finishes or closes.
+  server.prependListener('request', trackMemoryActivity);
+  server.prependListener('upgrade', (req, socket) => trackMemoryActivity(req, socket));
   server.on('connection', (socket) => {
     sockets.add(socket);
     socket.on('close', () => {
@@ -15,17 +22,33 @@ function attachServerShutdownHandling(server, options = {}) {
 
   const keepAliveTimeout = Number.isFinite(options.keepAliveTimeout)
     ? Math.max(0, options.keepAliveTimeout)
-    : 1000;
+    : 5000;
   const headersTimeout = Number.isFinite(options.headersTimeout)
     ? Math.max(keepAliveTimeout + 1000, options.headersTimeout)
-    : keepAliveTimeout + 1000;
+    : Math.max(60_000, keepAliveTimeout + 1000);
 
   server.keepAliveTimeout = keepAliveTimeout;
   server.headersTimeout = headersTimeout;
   server[SOCKET_TRACKER] = { sockets };
+  if (options.drainOnExit !== false) {
+    if (server.listening) proxyServers.add(server);
+    else server.once('listening', () => proxyServers.add(server));
+    server.once('close', () => proxyServers.delete(server));
+  }
   return server;
 }
 
+async function drainProxyServers(options = {}) {
+  await Promise.all([...proxyServers].map(server => new Promise((resolve, reject) => {
+    const timer = expediteServerShutdown(server, { forceAfterMs: options.forceAfterMs ?? 120_000 });
+    server.close(error => {
+      if (timer) clearTimeout(timer);
+      if (error && error.code !== 'ERR_SERVER_NOT_RUNNING') reject(error);
+      else resolve();
+    });
+  })));
+}
+
 function expediteServerShutdown(server, options = {}) {
   if (!server) {
     return null;
@@ -75,5 +98,7 @@ function expediteServerShutdown(server, options = {}) {
 
 module.exports = {
   attachServerShutdownHandling,
-  expediteServerShutdown
+  expediteServerShutdown,
+  drainProxyServers,
+  PROXY_IDLE_TIMEOUT_MS
 };

package/src/shared/proxy-transport.js

@@ -0,0 +1,33 @@
+'use strict';
+
+// Connection headers describe one transport hop, not the downstream socket.
+function downstreamHeaders(headers = {}) {
+  const result = { ...headers };
+  const connectionHeaders = String(headers.connection || '').split(',').map(name => name.trim().toLowerCase());
+  for (const name of ['connection', 'keep-alive', 'proxy-connection', 'proxy-authenticate',
+    'proxy-authorization', 'te', 'trailer', 'transfer-encoding', 'upgrade', ...connectionHeaders]) {
+    delete result[name];
+  }
+  return result;
+}
+
+function bindProxyRequest(proxyReq, res) {
+  if (!res) return;
+  const abort = () => {
+    if (!res.writableEnded && typeof proxyReq.destroy === 'function') proxyReq.destroy();
+  };
+  res.once('close', abort);
+  proxyReq.once('close', () => res.removeListener('close', abort));
+  if (res.destroyed) abort();
+}
+
+function prepareProxyResponse(proxyRes, res) {
+  proxyRes.headers = downstreamHeaders(proxyRes.headers);
+  const fail = error => {
+    if (res && !res.destroyed) res.destroy(error);
+  };
+  proxyRes.once('error', fail);
+  proxyRes.once('aborted', () => fail(new Error('Upstream response aborted')));
+}
+
+module.exports = { downstreamHeaders, bindProxyRequest, prepareProxyResponse };