codex-endpoint-switcher 1.0.0 → 1.0.1

package/README.md

@@ -68,3 +68,42 @@ codex-switcher remove-access
 ```text
 http://localhost:3186
 ```
+
+## 更新 npm 包
+
+先进入项目目录：
+
+```bash
+cd C:\Users\33825\Desktop\codex-profile-desktop
+```
+
+发布前先检查这次会打进 npm 包里的文件：
+
+```bash
+npm run release:check
+```
+
+如果只是小修复，直接发补丁版本：
+
+```bash
+npm run release:patch
+```
+
+如果是新增功能但兼容旧版：
+
+```bash
+npm run release:minor
+```
+
+如果有破坏性改动：
+
+```bash
+npm run release:major
+```
+
+说明：
+
+- `release:patch` 会自动把版本从 `1.0.0` 升到 `1.0.1` 这一类补丁版本，然后执行 `npm publish`
+- `release:minor` 会自动把版本从 `1.0.0` 升到 `1.1.0` 这一类功能版本，然后执行 `npm publish`
+- `release:major` 会自动把版本从 `1.0.0` 升到 `2.0.0` 这一类大版本，然后执行 `npm publish`
+- 如果 npm 开启了 2FA，发布时仍然会要求输入验证码

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-endpoint-switcher",
-  "version": "1.0.0",
+  "version": "1.0.1",
   "description": "用于切换 Codex URL 和 Key 的本地网页控制台与 npm CLI",
   "main": "src/main/main.js",
   "bin": {
@@ -23,6 +23,10 @@
     "dev:web": "node src/web/server.js",
     "cli": "node bin/codex-switcher.js",
     "pack:npm": "npm pack",
+    "release:check": "npm pack --dry-run",
+    "release:patch": "npm version patch --no-git-tag-version && npm publish",
+    "release:minor": "npm version minor --no-git-tag-version && npm publish",
+    "release:major": "npm version major --no-git-tag-version && npm publish",
     "build:portable": "electron-builder --win portable",
     "build:installer": "electron-builder --win nsis"
   },

package/src/main/main.js

@@ -46,6 +46,10 @@ function registerHandlers() {
     return profileManager.switchEndpoint(payload.id);
   });
 
+  ipcMain.handle("proxy:enable", async () => {
+    return profileManager.enableProxyMode();
+  });
+
   ipcMain.handle("paths:get", async () => {
     return profileManager.getManagedPaths();
   });

package/src/main/preload.js

@@ -19,6 +19,9 @@ contextBridge.exposeInMainWorld("codexDesktop", {
   switchEndpoint(payload) {
     return ipcRenderer.invoke("endpoints:switch", payload);
   },
+  enableProxyMode() {
+    return ipcRenderer.invoke("proxy:enable");
+  },
   getPaths() {
     return ipcRenderer.invoke("paths:get");
   },

package/src/main/profile-manager.js

@@ -8,6 +8,9 @@ const backupDir = path.join(codexRoot, "backup");
 const mainConfigPath = path.join(codexRoot, "config.toml");
 const authConfigPath = path.join(codexRoot, "auth.json");
 const endpointStorePath = path.join(codexRoot, "endpoint-presets.json");
+const endpointStatePath = path.join(codexRoot, "endpoint-switcher-state.json");
+const proxyPort = 3187;
+const proxyBaseUrl = `http://127.0.0.1:${proxyPort}/`;
 
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -206,20 +209,12 @@ function updateProviderBaseUrl(content, provider, nextUrl) {
   return output.join(newline);
 }
 
-function buildEndpointResponse(endpoint, activeId) {
-  return {
-    id: endpoint.id,
-    note: endpoint.note,
-    url: endpoint.url,
-    key: endpoint.key,
-    maskedKey: maskKey(endpoint.key),
-    createdAt: endpoint.createdAt,
-    updatedAt: endpoint.updatedAt,
-    isActive: endpoint.id === activeId,
-  };
+function isProxyBaseUrl(url) {
+  const normalized = String(url || "").replace(/\/+$/, "");
+  return normalized === proxyBaseUrl.replace(/\/+$/, "");
 }
 
-async function ensureEndpointStore() {
+async function ensureStorage() {
   await ensureFileExists(mainConfigPath, `未找到 Codex 主配置文件：${mainConfigPath}`);
   await ensureDirectory(backupDir);
 
@@ -228,10 +223,19 @@ async function ensureEndpointStore() {
   } catch {
     await writeJsonFile(endpointStorePath, []);
   }
+
+  try {
+    await fs.access(endpointStatePath);
+  } catch {
+    await writeJsonFile(endpointStatePath, {
+      activeEndpointId: "",
+      proxyModeEnabled: false,
+    });
+  }
 }
 
 async function readEndpointStore() {
-  await ensureEndpointStore();
+  await ensureStorage();
   const data = await readJsonFile(endpointStorePath, []);
   return Array.isArray(data) ? data : [];
 }
@@ -240,19 +244,41 @@ async function writeEndpointStore(endpoints) {
   await writeJsonFile(endpointStorePath, endpoints);
 }
 
+async function readEndpointState() {
+  await ensureStorage();
+  const state = await readJsonFile(endpointStatePath, {
+    activeEndpointId: "",
+    proxyModeEnabled: false,
+  });
+
+  return {
+    activeEndpointId: String(state.activeEndpointId || "").trim(),
+    proxyModeEnabled: Boolean(state.proxyModeEnabled),
+  };
+}
+
+async function writeEndpointState(state) {
+  await writeJsonFile(endpointStatePath, {
+    activeEndpointId: String(state.activeEndpointId || "").trim(),
+    proxyModeEnabled: Boolean(state.proxyModeEnabled),
+  });
+}
+
 async function readCurrentConfigAndAuth() {
-  await ensureEndpointStore();
+  await ensureStorage();
   const configContent = await readTextFile(mainConfigPath);
   const authConfig = await readJsonFile(authConfigPath, {});
   const provider = readTomlScalar(configContent, "model_provider");
+  const baseUrl = readProviderBaseUrl(configContent, provider);
 
   return {
     configContent,
     authConfig,
     provider,
     model: readTomlScalar(configContent, "model"),
-    baseUrl: readProviderBaseUrl(configContent, provider),
+    baseUrl,
     apiKey: String(authConfig.OPENAI_API_KEY || "").trim(),
+    proxyModeEnabled: isProxyBaseUrl(baseUrl),
   };
 }
 
@@ -276,45 +302,78 @@ async function backupCurrentState() {
   };
 }
 
-async function getCurrentEndpointSummary() {
-  const [currentState, endpoints] = await Promise.all([
+function buildEndpointResponse(endpoint, activeId) {
+  return {
+    id: endpoint.id,
+    note: endpoint.note,
+    url: endpoint.url,
+    key: endpoint.key,
+    maskedKey: maskKey(endpoint.key),
+    createdAt: endpoint.createdAt,
+    updatedAt: endpoint.updatedAt,
+    isActive: endpoint.id === activeId,
+  };
+}
+
+async function resolveActiveEndpointContext() {
+  const [currentState, endpoints, state] = await Promise.all([
     readCurrentConfigAndAuth(),
     readEndpointStore(),
+    readEndpointState(),
   ]);
 
-  const activeEndpoint = endpoints.find(
-    (item) => item.url === currentState.baseUrl && item.key === currentState.apiKey,
-  );
+  let activeEndpoint = null;
+
+  if (currentState.proxyModeEnabled && state.activeEndpointId) {
+    activeEndpoint = endpoints.find((item) => item.id === state.activeEndpointId) || null;
+  }
+
+  if (!activeEndpoint) {
+    activeEndpoint =
+      endpoints.find(
+        (item) => item.url === currentState.baseUrl && item.key === currentState.apiKey,
+      ) || null;
+  }
 
   return {
-    model: currentState.model,
-    provider: currentState.provider,
-    currentUrl: currentState.baseUrl,
-    currentKeyMasked: maskKey(currentState.apiKey),
-    currentNote: activeEndpoint ? activeEndpoint.note : "未命名连接",
+    currentState,
+    endpoints,
+    state,
+    activeEndpoint,
     activeEndpointId: activeEndpoint ? activeEndpoint.id : "",
+  };
+}
+
+async function getCurrentEndpointSummary() {
+  const context = await resolveActiveEndpointContext();
+  const currentNote = context.activeEndpoint ? context.activeEndpoint.note : "未命名连接";
+
+  return {
+    model: context.currentState.model,
+    provider: context.currentState.provider,
+    currentUrl: context.activeEndpoint ? context.activeEndpoint.url : context.currentState.baseUrl,
+    currentKeyMasked: context.activeEndpoint
+      ? maskKey(context.activeEndpoint.key)
+      : maskKey(context.currentState.apiKey),
+    currentNote,
+    activeEndpointId: context.activeEndpointId,
     endpointStorePath,
+    endpointStatePath,
     authConfigPath,
     mainConfigPath,
-    totalEndpoints: endpoints.length,
+    totalEndpoints: context.endpoints.length,
+    proxyModeEnabled: context.currentState.proxyModeEnabled,
+    proxyBaseUrl,
+    hotReloadReady: context.currentState.proxyModeEnabled,
   };
 }
 
 async function listEndpoints() {
-  const [currentState, endpoints] = await Promise.all([
-    readCurrentConfigAndAuth(),
-    readEndpointStore(),
-  ]);
-
-  const activeEndpoint = endpoints.find(
-    (item) => item.url === currentState.baseUrl && item.key === currentState.apiKey,
-  );
-  const activeId = activeEndpoint ? activeEndpoint.id : "";
-
-  return endpoints
+  const context = await resolveActiveEndpointContext();
+  return context.endpoints
     .slice()
     .sort((left, right) => String(right.updatedAt).localeCompare(String(left.updatedAt)))
-    .map((endpoint) => buildEndpointResponse(endpoint, activeId));
+    .map((endpoint) => buildEndpointResponse(endpoint, context.activeEndpointId));
 }
 
 async function createEndpoint(payload) {
@@ -378,6 +437,14 @@ async function deleteEndpoint(id) {
   const [removed] = endpoints.splice(index, 1);
   await writeEndpointStore(endpoints);
 
+  const state = await readEndpointState();
+  if (state.activeEndpointId === removed.id) {
+    await writeEndpointState({
+      ...state,
+      activeEndpointId: "",
+    });
+  }
+
   return {
     id: removed.id,
     note: removed.note,
@@ -397,24 +464,121 @@ async function switchEndpoint(id) {
     throw new Error("未找到要切换的端点。");
   }
 
-  const { configContent, authConfig, provider } = await readCurrentConfigAndAuth();
-  if (!provider) {
+  const currentState = await readCurrentConfigAndAuth();
+
+  if (currentState.proxyModeEnabled) {
+    await writeEndpointState({
+      activeEndpointId: target.id,
+      proxyModeEnabled: true,
+    });
+
+    return {
+      ...(await getCurrentEndpointSummary()),
+      switchedViaProxy: true,
+      nextRequestHotReloaded: true,
+    };
+  }
+
+  if (!currentState.provider) {
     throw new Error("当前 config.toml 未找到 model_provider。");
   }
 
-  const nextConfigContent = updateProviderBaseUrl(configContent, provider, target.url);
+  const nextConfigContent = updateProviderBaseUrl(
+    currentState.configContent,
+    currentState.provider,
+    target.url,
+  );
   const nextAuthConfig = {
-    ...authConfig,
+    ...currentState.authConfig,
     OPENAI_API_KEY: target.key,
   };
 
   const backupPaths = await backupCurrentState();
   await writeTextFile(mainConfigPath, nextConfigContent);
   await writeJsonFile(authConfigPath, nextAuthConfig);
+  await writeEndpointState({
+    activeEndpointId: target.id,
+    proxyModeEnabled: false,
+  });
 
   return {
     ...backupPaths,
     ...(await getCurrentEndpointSummary()),
+    switchedViaProxy: false,
+    nextRequestHotReloaded: false,
+  };
+}
+
+async function enableProxyMode() {
+  const [currentState, endpoints, state] = await Promise.all([
+    readCurrentConfigAndAuth(),
+    readEndpointStore(),
+    readEndpointState(),
+  ]);
+
+  if (!currentState.provider) {
+    throw new Error("当前 config.toml 未找到 model_provider。");
+  }
+
+  let workingEndpoints = endpoints.slice();
+  let activeEndpoint =
+    workingEndpoints.find(
+      (item) => item.url === currentState.baseUrl && item.key === currentState.apiKey,
+    ) || null;
+
+  if (!activeEndpoint && !currentState.proxyModeEnabled) {
+    const now = new Date().toISOString();
+    activeEndpoint = {
+      id: randomUUID(),
+      note: "当前连接",
+      url: currentState.baseUrl,
+      key: currentState.apiKey,
+      createdAt: now,
+      updatedAt: now,
+    };
+    workingEndpoints.push(activeEndpoint);
+    await writeEndpointStore(workingEndpoints);
+  }
+
+  const nextActiveId = activeEndpoint
+    ? activeEndpoint.id
+    : state.activeEndpointId || (workingEndpoints[0] ? workingEndpoints[0].id : "");
+
+  if (!nextActiveId) {
+    throw new Error("请先新增至少一条连接，再开启热更新模式。");
+  }
+
+  if (!currentState.proxyModeEnabled) {
+    const backupPaths = await backupCurrentState();
+    const nextConfigContent = updateProviderBaseUrl(
+      currentState.configContent,
+      currentState.provider,
+      proxyBaseUrl,
+    );
+    await writeTextFile(mainConfigPath, nextConfigContent);
+    await writeEndpointState({
+      activeEndpointId: nextActiveId,
+      proxyModeEnabled: true,
+    });
+
+    return {
+      ...backupPaths,
+      ...(await getCurrentEndpointSummary()),
+      oneTimeRestartRequired: true,
+      message:
+        "已切到本地代理模式。已经打开着的旧 Codex 会话需要手动重开一次；之后同一会话内即可热更新。",
+    };
+  }
+
+  await writeEndpointState({
+    activeEndpointId: nextActiveId,
+    proxyModeEnabled: true,
+  });
+
+  return {
+    ...(await getCurrentEndpointSummary()),
+    oneTimeRestartRequired: false,
+    message: "热更新模式已经开启。",
   };
 }
 
@@ -425,15 +589,39 @@ function getManagedPaths() {
     mainConfigPath,
     authConfigPath,
     endpointStorePath,
+    endpointStatePath,
+    proxyBaseUrl,
+    proxyPort,
+  };
+}
+
+async function getProxyTarget() {
+  const context = await resolveActiveEndpointContext();
+  if (!context.activeEndpoint) {
+    throw new Error("当前没有激活的连接，无法进行代理转发。");
+  }
+
+  return {
+    id: context.activeEndpoint.id,
+    note: context.activeEndpoint.note,
+    url: context.activeEndpoint.url,
+    key: context.activeEndpoint.key,
+    proxyModeEnabled: context.currentState.proxyModeEnabled,
+    proxyBaseUrl,
+    proxyPort,
   };
 }
 
 module.exports = {
   createEndpoint,
   deleteEndpoint,
+  enableProxyMode,
   getCurrentEndpointSummary,
   getManagedPaths,
+  getProxyTarget,
   listEndpoints,
+  proxyBaseUrl,
+  proxyPort,
   switchEndpoint,
   updateEndpoint,
 };

package/src/renderer/index.html

@@ -64,6 +64,18 @@
               <span class="metric-label">模型</span>
               <strong id="currentModel">-</strong>
             </article>
+            <article class="metric-card metric-card-wide">
+              <span class="metric-label">热更新模式</span>
+              <strong id="proxyModeStatus">未开启</strong>
+              <p class="field-hint" id="proxyModeHint">
+                当前还是直连模式。开启后，后续同一 Codex 会话可在下一次请求时热更新到新 URL/Key。
+              </p>
+              <div class="action-row metric-actions">
+                <button id="enableProxyModeButton" type="button" class="secondary-button">
+                  开启热更新模式
+                </button>
+              </div>
+            </article>
           </div>
         </section>
 

package/src/renderer/renderer.js

@@ -51,6 +51,11 @@ function createWebBridge() {
         body: JSON.stringify(payload),
       });
     },
+    enableProxyMode() {
+      return request("/api/proxy/enable", {
+        method: "POST",
+      });
+    },
     getPaths() {
       return request("/api/paths");
     },
@@ -120,8 +125,18 @@ function renderCurrent() {
   $("#currentBaseUrl").textContent = current.currentUrl || "-";
   $("#currentKeyMasked").textContent = current.currentKeyMasked || "-";
   $("#currentModel").textContent = current.model || "-";
+  $("#proxyModeStatus").textContent = current.proxyModeEnabled
+    ? `已开启，固定代理：${current.proxyBaseUrl}`
+    : "未开启";
+  $("#proxyModeHint").textContent = current.proxyModeEnabled
+    ? "当前 Codex 只要已经接入本地代理，后续同一会话内切换连接会在下一次请求时热更新。"
+    : "当前还是直连模式。开启后需要把已打开的旧 Codex 会话重开一次；之后同一会话即可热更新。";
+  $("#enableProxyModeButton").disabled = current.proxyModeEnabled;
+  $("#enableProxyModeButton").textContent = current.proxyModeEnabled
+    ? "热更新模式已开启"
+    : "开启热更新模式";
   $("#heroBadge").textContent = current.currentNote
-    ? `当前连接：${current.currentNote}`
+    ? `${current.proxyModeEnabled ? "热更新中" : "当前连接"}：${current.currentNote}`
     : "当前未匹配到已保存连接";
 }
 
@@ -241,10 +256,14 @@ async function handleSwitchEndpoint(id, note) {
     setStatus(`正在切换到：${note} ...`, "info");
     const result = await bridge.switchEndpoint({ id });
     await refreshDashboard(false);
-    setStatus(
-      `已切换到 ${note}。已备份 config.toml 和 auth.json，下一条 codex 命令直接生效。`,
-      "success",
-    );
+    if (result.switchedViaProxy) {
+      setStatus(`已切换到 ${note}。当前会话下一次请求会直接走新的 URL/Key。`, "success");
+    } else {
+      setStatus(
+        `已切换到 ${note}。当前还是直连模式，只有新开的 Codex 会话会立即使用新配置。`,
+        "success",
+      );
+    }
     return result;
   } catch (error) {
     setStatus(`切换失败：${error.message}`, "error");
@@ -252,6 +271,24 @@ async function handleSwitchEndpoint(id, note) {
   }
 }
 
+async function handleEnableProxyMode() {
+  try {
+    setStatus("正在切到热更新代理模式 ...", "info");
+    const result = await bridge.enableProxyMode();
+    await refreshDashboard(false);
+    if (result.oneTimeRestartRequired) {
+      setStatus(
+        "热更新模式已开启。请把当前已经打开着的旧 Codex 会话重开一次；之后同一会话内即可热更新。",
+        "success",
+      );
+    } else {
+      setStatus("热更新模式已开启。当前会话后续请求可直接热更新到新连接。", "success");
+    }
+  } catch (error) {
+    setStatus(`开启热更新模式失败：${error.message}`, "error");
+  }
+}
+
 async function handleSubmitEndpoint(event) {
   event.preventDefault();
   const id = $("#endpointId").value.trim();
@@ -320,6 +357,7 @@ function bindEvents() {
     resetForm();
     setStatus("已清空表单。", "info");
   });
+  $("#enableProxyModeButton").addEventListener("click", handleEnableProxyMode);
   $("#openCodexRootButton").addEventListener("click", () => {
     if (state.paths?.codexRoot) {
       handleOpenPath(state.paths.codexRoot, " Codex 目录");

package/src/renderer/styles.css

@@ -300,6 +300,10 @@ input[readonly] {
   gap: 10px;
 }
 
+.metric-actions {
+  margin-top: 12px;
+}
+
 .primary-button,
 .secondary-button,
 .ghost-button {

package/src/web/launcher.js

@@ -7,7 +7,9 @@ const projectRoot = path.resolve(__dirname, "../..");
 const runtimeDir = path.join(projectRoot, "runtime");
 const serverEntryPath = path.join(__dirname, "server.js");
 const port = Number(process.env.PORT || 3186);
+const proxyPort = 3187;
 const healthUrl = `http://127.0.0.1:${port}/api/health`;
+const proxyHealthUrl = `http://127.0.0.1:${proxyPort}/__switcher/health`;
 const consoleUrl = `http://localhost:${port}`;
 
 function ensureRuntimeDir() {
@@ -45,7 +47,8 @@ function requestJson(url, timeoutMs = 1200) {
 async function checkServerHealth() {
   try {
     const payload = await requestJson(healthUrl);
-    return Boolean(payload && payload.ok);
+    const proxyPayload = await requestJson(proxyHealthUrl);
+    return Boolean(payload && payload.ok && proxyPayload && proxyPayload.ok);
   } catch {
     return false;
   }
@@ -211,6 +214,7 @@ async function handleCommand(command) {
             running,
             url: consoleUrl,
             port,
+            proxyPort,
           },
           null,
           2,
@@ -245,4 +249,5 @@ module.exports = {
   runtimeDir,
   consoleUrl,
   port,
+  proxyPort,
 };

package/src/web/proxy-server.js

@@ -0,0 +1,69 @@
+const http = require("node:http");
+const https = require("node:https");
+const profileManager = require("../main/profile-manager");
+
+function createProxyServer() {
+  return http.createServer(async (req, res) => {
+    try {
+      if (req.url === "/__switcher/health") {
+        res.writeHead(200, { "Content-Type": "application/json; charset=utf-8" });
+        res.end(JSON.stringify({ ok: true, proxyBaseUrl: profileManager.proxyBaseUrl }));
+        return;
+      }
+
+      const target = await profileManager.getProxyTarget();
+      const upstreamBase = new URL(target.url);
+      const requestPath = req.url && req.url.startsWith("/") ? req.url : `/${req.url || ""}`;
+      const upstreamUrl = new URL(requestPath, upstreamBase);
+      const requestModule = upstreamUrl.protocol === "https:" ? https : http;
+      const headers = {
+        ...req.headers,
+        host: upstreamUrl.host,
+        authorization: `Bearer ${target.key}`,
+      };
+
+      delete headers.connection;
+
+      const upstreamRequest = requestModule.request(
+        upstreamUrl,
+        {
+          method: req.method,
+          headers,
+        },
+        (upstreamResponse) => {
+          res.writeHead(upstreamResponse.statusCode || 502, upstreamResponse.headers);
+          upstreamResponse.pipe(res);
+        },
+      );
+
+      upstreamRequest.on("error", (error) => {
+        if (!res.headersSent) {
+          res.writeHead(502, { "Content-Type": "application/json; charset=utf-8" });
+        }
+        res.end(
+          JSON.stringify({
+            ok: false,
+            error: `代理转发失败：${error.message}`,
+          }),
+        );
+      });
+
+      req.pipe(upstreamRequest);
+    } catch (error) {
+      if (!res.headersSent) {
+        res.writeHead(500, { "Content-Type": "application/json; charset=utf-8" });
+      }
+
+      res.end(
+        JSON.stringify({
+          ok: false,
+          error: error instanceof Error ? error.message : String(error),
+        }),
+      );
+    }
+  });
+}
+
+module.exports = {
+  createProxyServer,
+};

package/src/web/server.js

@@ -2,6 +2,7 @@ const path = require("node:path");
 const { exec } = require("node:child_process");
 const express = require("express");
 const profileManager = require("../main/profile-manager");
+const { createProxyServer } = require("./proxy-server");
 
 function wrapAsync(handler) {
   return async (req, res) => {
@@ -77,6 +78,13 @@ function createApp() {
     }),
   );
 
+  app.post(
+    "/api/proxy/enable",
+    wrapAsync(async () => {
+      return profileManager.enableProxyMode();
+    }),
+  );
+
   app.post(
     "/api/open-path",
     wrapAsync(async (req) => {
@@ -110,16 +118,49 @@ function createApp() {
 function startServer(options = {}) {
   const port = Number(options.port || process.env.PORT || 3186);
   const app = createApp();
-  const server = app.listen(port, () => {
+  const proxyServer = createProxyServer();
+  const proxyPort = profileManager.proxyPort;
+  const webServer = app.listen(port, () => {
     const url = `http://localhost:${port}`;
     console.log(`Codex 网页控制台已启动：${url}`);
+    console.log(`Codex 热更新代理已启动：${profileManager.proxyBaseUrl}`);
 
     if (options.autoOpen !== false && process.env.AUTO_OPEN_BROWSER !== "false") {
       exec(`cmd /c start "" "${url}"`);
     }
   });
 
-  return server;
+  proxyServer.listen(proxyPort);
+
+  return {
+    webServer,
+    proxyServer,
+    close(callback) {
+      let pending = 2;
+      let closed = false;
+
+      function done(error) {
+        if (closed) {
+          return;
+        }
+
+        if (error) {
+          closed = true;
+          callback(error);
+          return;
+        }
+
+        pending -= 1;
+        if (pending === 0) {
+          closed = true;
+          callback();
+        }
+      }
+
+      webServer.close((error) => done(error));
+      proxyServer.close((error) => done(error));
+    },
+  };
 }
 
 if (require.main === module) {