coding-tool-x 3.9.5-261009 → 3.9.5-261013

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
 };