coding-tool-x 3.9.4 → 3.9.5-261012

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/api/mcp.js

@@ -326,8 +326,8 @@ router.post('/import/:platform', async (req, res) => {
       success: true,
       imported: count,
       message: count > 0
-        ? `成功从 ${resolved.key} 导入 ${count} 个 MCP 服务器`
-        : `${resolved.key} 没有可导入的 MCP 服务器`
+        ? `已从 ${resolved.key} 导入或更新 ${count} 个 MCP 服务器`
+        : `${resolved.key} 的 MCP 配置没有新增或变更`
     });
   } catch (error) {
     console.error('[MCP API] Import failed:', sanitizeErrorMessage(error.message || error));

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/mcp-service.js

@@ -9,6 +9,7 @@ const path = require('path');
 const { spawn } = require('child_process');
 const { McpClient, buildMissingCommandMessage, createMissingCommandHint } = require('./mcp-client');
 const mcpFormat = require('../../shared/mcp-format');
+const { importMcpServer } = require('../../shared/mcp-import');
 const { convertToOmpMcpFormat, convertFromOmpMcpFormat } = mcpFormat;
 const { PATHS } = require('../../config/paths');
 const { ControlManifestStore } = require('./control-manifest-store');
@@ -1072,25 +1073,7 @@ async function importGenericMcpServers(driver, platform, servers) {
 
   for (const [id, spec] of Object.entries(mcpServers)) {
     if (!spec || typeof spec !== 'object' || Array.isArray(spec)) continue;
-    if (servers[id]) {
-      servers[id].apps = normalizeServerApps(servers[id].apps, {});
-      if (!servers[id].apps[platform]) {
-        servers[id].apps[platform] = true;
-        count++;
-      }
-      continue;
-    }
-
-    const now = Date.now();
-    servers[id] = {
-      id,
-      name: id,
-      server: normalizeServerSpec(spec),
-      apps: { [platform]: true },
-      createdAt: now,
-      updatedAt: now
-    };
-    count++;
+    if (importMcpServer(servers, { id, platform, spec: normalizeServerSpec(spec) })) count++;
   }
 
   return count;

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/driver-factories/mcp.js

@@ -8,6 +8,7 @@ const tomlStringify = require('@iarna/toml').stringify;
 const { ok, failed } = require('../driver-result');
 const { extractServerSpec, convertToCodexFormat, convertFromCodexFormat, convertToOmpMcpFormat, convertFromOmpMcpFormat, convertToOpenCodeFormat, convertFromOpenCodeFormat } = require('../mcp-format');
 const { redactSecrets, validateMcpId } = require('../project-config');
+const { importMcpServer } = require('../mcp-import');
 
 const SCHEMA_URL = 'https://raw.githubusercontent.com/can1357/oh-my-omp/main/packages/coding-agent/src/config/mcp-schema.json';
 
@@ -192,14 +193,7 @@ function createMcpDriver({ platform, ...context } = {}) {
     let count = 0;
     for (const [id, spec] of Object.entries(map)) {
       if (!spec || typeof spec !== 'object' || Array.isArray(spec)) continue;
-      if (servers[id]) {
-        servers[id].apps = { ...(servers[id].apps || {}), [platform]: true };
-        count += 1;
-        continue;
-      }
-      const now = Date.now();
-      servers[id] = { id, name: id, server: internalSpec(spec), apps: { [platform]: true }, createdAt: now, updatedAt: now };
-      count += 1;
+      if (importMcpServer(servers, { id, platform, spec: internalSpec(spec) })) count += 1;
     }
     return count;
   }

package/src/shared/mcp-import.js

@@ -0,0 +1,107 @@
+'use strict';
+
+const { isDeepStrictEqual } = require('util');
+const { validateMcpId } = require('./project-config');
+
+const REDACTED_VALUES = new Set(['[REDACTED]', '[redacted]', '[EXPRESSION]']);
+
+function normalizeImportedSpec(spec) {
+  if (!spec || typeof spec !== 'object' || Array.isArray(spec)) return spec;
+  return { ...spec, type: spec.type || 'stdio' };
+}
+
+function restoreRedactedUrl(incoming, existing) {
+  if (typeof incoming !== 'string' || typeof existing !== 'string') return incoming;
+  try {
+    const nextUrl = new URL(incoming);
+    const previousUrl = new URL(existing);
+    const isRedactedPart = value => {
+      try {
+        return REDACTED_VALUES.has(decodeURIComponent(value));
+      } catch (_) {
+        return false;
+      }
+    };
+    const decodePart = value => {
+      try {
+        return decodeURIComponent(value);
+      } catch (_) {
+        return value;
+      }
+    };
+    if (isRedactedPart(nextUrl.username) && previousUrl.username) {
+      nextUrl.username = decodePart(previousUrl.username);
+    }
+    if (isRedactedPart(nextUrl.password) && previousUrl.password) {
+      nextUrl.password = decodePart(previousUrl.password);
+    }
+    for (const [key, value] of nextUrl.searchParams.entries()) {
+      if (REDACTED_VALUES.has(value) && previousUrl.searchParams.has(key)) {
+        nextUrl.searchParams.set(key, previousUrl.searchParams.get(key));
+      }
+    }
+    return nextUrl.toString();
+  } catch (_) {
+    return incoming;
+  }
+}
+
+function restoreRedactedValues(incoming, existing, key = '') {
+  if (REDACTED_VALUES.has(incoming)) return existing === undefined ? incoming : existing;
+  if (key === 'url') return restoreRedactedUrl(incoming, existing);
+  if (Array.isArray(incoming)) {
+    const previous = Array.isArray(existing) ? existing : [];
+    return incoming.map((value, index) => restoreRedactedValues(value, previous[index]));
+  }
+  if (!incoming || typeof incoming !== 'object') return incoming;
+  const previous = existing && typeof existing === 'object' && !Array.isArray(existing) ? existing : {};
+  return Object.fromEntries(Object.entries(incoming).map(([childKey, value]) => [
+    childKey,
+    restoreRedactedValues(value, previous[childKey], childKey)
+  ]));
+}
+
+function importMcpServer(servers, { id, platform, spec, name } = {}) {
+  let normalizedId;
+  try {
+    normalizedId = validateMcpId(id);
+  } catch (_) {
+    return false;
+  }
+  const importedSpec = normalizeImportedSpec(spec);
+  const existing = servers[normalizedId];
+
+  if (!existing) {
+    const now = Date.now();
+    servers[normalizedId] = {
+      id: normalizedId,
+      name: typeof name === 'string' && name.trim() ? name : normalizedId,
+      server: importedSpec,
+      apps: { [platform]: true },
+      createdAt: now,
+      updatedAt: now
+    };
+    return true;
+  }
+
+  // Treat imports as full snapshots, restoring only values hidden by the platform.
+  const nextSpec = restoreRedactedValues(importedSpec, existing.server);
+  const nextApps = {
+    ...(existing.apps && typeof existing.apps === 'object' && !Array.isArray(existing.apps)
+      ? existing.apps
+      : {}),
+    [platform]: true
+  };
+  const nextName = typeof name === 'string' && name.trim() ? name : existing.name || normalizedId;
+  const changed = !isDeepStrictEqual(existing.server, nextSpec)
+    || !isDeepStrictEqual(existing.apps || {}, nextApps)
+    || existing.name !== nextName;
+
+  existing.server = nextSpec;
+  existing.apps = nextApps;
+  existing.name = nextName;
+  if (changed) existing.updatedAt = Date.now();
+  return changed;
+}
+
+module.exports = { importMcpServer };

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