codex-endpoint-switcher 1.5.0 → 1.6.1

package/README.md

@@ -77,6 +77,11 @@ codex-switcher remove-access
 http://localhost:3186
 ```
 
+说明：
+
+- 本地控制台和热更新代理默认只监听 `127.0.0.1`
+- 不再暴露到局域网，避免其他设备直接访问你的本地 Key 管理接口
+
 ## 账号配置同步
 
 网页控制台现在支持“账号 + 密码”的同步方式。
@@ -144,6 +149,7 @@ codex-switcher sync-server
 - 如果你发布了新版本，其他用户打开控制台后会看到“发现新版本”的提示
 - 用户可以直接点 `立即更新`，程序会自动关闭、更新并重新打开
 - 也可以继续使用“复制升级命令”手动更新
+- 上一次自动更新的成功或失败结果会记录到本地，下次打开控制台会显示结果
 
 也可以用 CLI 手动检查：
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-endpoint-switcher",
-  "version": "1.5.0",
+  "version": "1.6.1",
   "description": "用于切换 Codex URL 和 Key 的本地网页控制台与 npm CLI",
   "main": "src/main/main.js",
   "bin": {

package/src/main/auto-update-runner.js

@@ -0,0 +1,242 @@
+const fs = require("node:fs/promises");
+const { spawn } = require("node:child_process");
+
+const WAIT_PARENT_EXIT_TIMEOUT_MS = 20000;
+const WAIT_PARENT_POLL_MS = 400;
+
+function sleep(timeoutMs) {
+  return new Promise((resolve) => {
+    setTimeout(resolve, timeoutMs);
+  });
+}
+
+async function appendLog(logPath, text) {
+  await fs.appendFile(logPath, text, "utf8");
+}
+
+async function writeState(statePath, payload) {
+  await fs.writeFile(statePath, `${JSON.stringify(payload, null, 2)}\n`, "utf8");
+}
+
+function runProcess(command, args, options = {}) {
+  return new Promise((resolve) => {
+    const child = spawn(command, args, {
+      cwd: options.cwd,
+      env: options.env,
+      stdio: ["ignore", "pipe", "pipe"],
+      windowsHide: true,
+    });
+
+    let stdout = "";
+    let stderr = "";
+
+    child.stdout.on("data", (chunk) => {
+      stdout += chunk.toString("utf8");
+    });
+
+    child.stderr.on("data", (chunk) => {
+      stderr += chunk.toString("utf8");
+    });
+
+    child.on("exit", (code) => {
+      resolve({
+        code: Number(code || 0),
+        stdout,
+        stderr,
+      });
+    });
+
+    child.on("error", (error) => {
+      resolve({
+        code: 1,
+        stdout,
+        stderr: `${stderr}${error instanceof Error ? error.message : String(error)}\n`,
+      });
+    });
+  });
+}
+
+function isProcessAlive(pid) {
+  try {
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+async function forceTerminateProcess(pid) {
+  if (!pid || pid <= 0) {
+    return;
+  }
+
+  if (process.platform === "win32") {
+    await runProcess("cmd.exe", ["/d", "/s", "/c", `taskkill /PID ${pid} /F`]);
+    return;
+  }
+
+  try {
+    process.kill(pid, "SIGTERM");
+  } catch {
+    // 进程已结束时忽略。
+  }
+}
+
+async function waitForProcessExit(pid, logPath) {
+  if (!pid || pid <= 0) {
+    return;
+  }
+
+  const startedAt = Date.now();
+  while (Date.now() - startedAt < WAIT_PARENT_EXIT_TIMEOUT_MS) {
+    if (!isProcessAlive(pid)) {
+      await appendLog(logPath, `[${new Date().toISOString()}] 旧进程已退出：${pid}\n`);
+      return;
+    }
+
+    await sleep(WAIT_PARENT_POLL_MS);
+  }
+
+  await appendLog(
+    logPath,
+    `[${new Date().toISOString()}] 旧进程超时未退出，开始强制结束：${pid}\n`,
+  );
+  await forceTerminateProcess(pid);
+  await sleep(1200);
+}
+
+async function reopenConsole(payload) {
+  return runProcess(
+    payload.nodePath,
+    [payload.reopenBinPath, "open"],
+    {
+      cwd: process.cwd(),
+      env: process.env,
+    },
+  );
+}
+
+async function main() {
+  const encodedPayload = String(process.argv[2] || "").trim();
+  if (!encodedPayload) {
+    throw new Error("缺少自动更新参数。");
+  }
+
+  const payload = JSON.parse(Buffer.from(encodedPayload, "base64url").toString("utf8"));
+  const startedAt = new Date().toISOString();
+
+  await appendLog(
+    payload.logPath,
+    `[${startedAt}] 自动更新开始，当前版本 ${payload.currentVersion}\n`,
+  );
+
+  await writeState(payload.statePath, {
+    status: "running",
+    packageName: payload.packageName,
+    requestedVersion: "latest",
+    currentVersion: payload.currentVersion,
+    startedAt,
+    finishedAt: "",
+    logPath: payload.logPath,
+    reopen: payload.reopen,
+    lastError: "",
+  });
+
+  await sleep(Number(payload.waitSeconds || 3) * 1000);
+  await waitForProcessExit(Number(payload.parentPid || 0), payload.logPath);
+
+  const installResult = await runProcess(
+    payload.nodePath,
+    [payload.npmCliPath, "install", "-g", `${payload.packageName}@latest`],
+    {
+      cwd: process.cwd(),
+      env: process.env,
+    },
+  );
+
+  if (installResult.stdout) {
+    await appendLog(payload.logPath, installResult.stdout);
+  }
+  if (installResult.stderr) {
+    await appendLog(payload.logPath, installResult.stderr);
+  }
+
+  if (installResult.code !== 0) {
+    const finishedAt = new Date().toISOString();
+    const errorMessage = `npm 安装失败，退出码：${installResult.code}`;
+    await appendLog(payload.logPath, `[${finishedAt}] ${errorMessage}\n`);
+    await writeState(payload.statePath, {
+      status: "failed",
+      packageName: payload.packageName,
+      requestedVersion: "latest",
+      currentVersion: payload.currentVersion,
+      startedAt,
+      finishedAt,
+      logPath: payload.logPath,
+      reopen: payload.reopen,
+      lastError: errorMessage,
+    });
+    process.exit(1);
+  }
+
+  let reopenResult = { code: 0, stdout: "", stderr: "" };
+  if (payload.reopen) {
+    reopenResult = await reopenConsole(payload);
+    if (reopenResult.stdout) {
+      await appendLog(payload.logPath, reopenResult.stdout);
+    }
+    if (reopenResult.stderr) {
+      await appendLog(payload.logPath, reopenResult.stderr);
+    }
+  }
+
+  const finishedAt = new Date().toISOString();
+  const finalStatus = reopenResult.code === 0 ? "succeeded" : "failed";
+  const lastError =
+    reopenResult.code === 0 ? "" : `更新已完成，但重新打开控制台失败，退出码：${reopenResult.code}`;
+
+  await appendLog(
+    payload.logPath,
+    `[${finishedAt}] ${finalStatus === "succeeded" ? "自动更新完成" : lastError}\n`,
+  );
+  await writeState(payload.statePath, {
+    status: finalStatus,
+    packageName: payload.packageName,
+    requestedVersion: "latest",
+    currentVersion: payload.currentVersion,
+    startedAt,
+    finishedAt,
+    logPath: payload.logPath,
+    reopen: payload.reopen,
+    lastError,
+  });
+
+  if (finalStatus !== "succeeded") {
+    process.exit(1);
+  }
+}
+
+main().catch(async (error) => {
+  const message = error instanceof Error ? error.message : String(error);
+  if (process.argv[2]) {
+    try {
+      const payload = JSON.parse(Buffer.from(process.argv[2], "base64url").toString("utf8"));
+      const finishedAt = new Date().toISOString();
+      await appendLog(payload.logPath, `[${finishedAt}] 自动更新异常：${message}\n`);
+      await writeState(payload.statePath, {
+        status: "failed",
+        packageName: payload.packageName,
+        requestedVersion: "latest",
+        currentVersion: payload.currentVersion,
+        startedAt: finishedAt,
+        finishedAt,
+        logPath: payload.logPath,
+        reopen: payload.reopen,
+        lastError: message,
+      });
+    } catch {
+      // 参数损坏时无法再写状态，直接退出。
+    }
+  }
+  process.exit(1);
+});

package/src/main/main.js

@@ -28,6 +28,10 @@ function registerHandlers() {
     return profileManager.listEndpoints();
   });
 
+  ipcMain.handle("endpoints:get", async (_event, payload) => {
+    return profileManager.getEndpointById(payload.id);
+  });
+
   ipcMain.handle("endpoints:current", async () => {
     return profileManager.getCurrentEndpointSummary();
   });

package/src/main/preload.js

@@ -4,6 +4,9 @@ contextBridge.exposeInMainWorld("codexDesktop", {
   listEndpoints() {
     return ipcRenderer.invoke("endpoints:list");
   },
+  getEndpoint(payload) {
+    return ipcRenderer.invoke("endpoints:get", payload);
+  },
   getCurrentConfig() {
     return ipcRenderer.invoke("endpoints:current");
   },

package/src/main/profile-manager.js

@@ -440,12 +440,14 @@ async function backupEndpointData() {
   };
 }
 
-function buildEndpointResponse(endpoint, activeId) {
+function buildEndpointResponse(endpoint, activeId, options = {}) {
+  const includeSensitive = Boolean(options.includeSensitive);
+
   return {
     id: endpoint.id,
     note: endpoint.note,
     url: endpoint.url,
-    key: endpoint.key,
+    ...(includeSensitive ? { key: endpoint.key } : {}),
     maskedKey: maskKey(endpoint.key),
     createdAt: endpoint.createdAt,
     updatedAt: endpoint.updatedAt,
@@ -514,6 +516,23 @@ async function listEndpoints() {
     .map((endpoint) => buildEndpointResponse(endpoint, context.activeEndpointId));
 }
 
+async function getEndpointById(id) {
+  const safeId = String(id || "").trim();
+  if (!safeId) {
+    throw new Error("缺少要读取的端点 ID。");
+  }
+
+  const context = await resolveActiveEndpointContext();
+  const endpoint = context.endpoints.find((item) => item.id === safeId);
+  if (!endpoint) {
+    throw new Error("未找到要读取的端点。");
+  }
+
+  return buildEndpointResponse(endpoint, context.activeEndpointId, {
+    includeSensitive: true,
+  });
+}
+
 async function createEndpoint(payload) {
   const endpoint = validateEndpointPayload(payload);
   const endpoints = await readEndpointStore();
@@ -863,6 +882,7 @@ module.exports = {
   deleteEndpoint,
   enableProxyMode,
   exportSyncPackage,
+  getEndpointById,
   getCurrentEndpointSummary,
   getManagedPaths,
   getProxyTarget,

package/src/main/update-service.js

@@ -4,6 +4,8 @@ const fs = require("node:fs");
 const { spawn } = require("node:child_process");
 const packageInfo = require("../../package.json");
 
+const packageRoot = path.resolve(__dirname, "../..");
+const runnerEntryPath = path.join(__dirname, "auto-update-runner.js");
 const REGISTRY_BASE_URL = "https://registry.npmjs.org";
 const SUCCESS_CACHE_TTL_MS = 10 * 60 * 1000;
 const ERROR_CACHE_TTL_MS = 30 * 1000;
@@ -18,6 +20,57 @@ function getAutoUpdateLogPath() {
   return path.join(logDir, "codex-switcher-auto-update.log");
 }
 
+function getAutoUpdateStatePath() {
+  const stateDir = path.join(os.homedir(), ".codex");
+  fs.mkdirSync(stateDir, { recursive: true });
+  return path.join(stateDir, "codex-switcher-auto-update.json");
+}
+
+function readAutoUpdateState() {
+  try {
+    const content = fs.readFileSync(getAutoUpdateStatePath(), "utf8");
+    const parsed = JSON.parse(content);
+    return parsed && typeof parsed === "object" ? parsed : null;
+  } catch {
+    return null;
+  }
+}
+
+function writeAutoUpdateState(payload) {
+  fs.writeFileSync(
+    getAutoUpdateStatePath(),
+    `${JSON.stringify(payload, null, 2)}\n`,
+    "utf8",
+  );
+}
+
+function resolveRuntimePaths() {
+  const nodePath = process.execPath;
+  const nodeDir = path.dirname(nodePath);
+  const globalRootCandidates =
+    process.platform === "win32"
+      ? [path.join(nodeDir, "node_modules")]
+      : [path.join(nodeDir, "../lib/node_modules"), path.join(nodeDir, "node_modules")];
+
+  const npmCliPath = globalRootCandidates
+    .map((basePath) => path.resolve(basePath, "npm/bin/npm-cli.js"))
+    .find((targetPath) => fs.existsSync(targetPath));
+
+  if (!npmCliPath) {
+    throw new Error("未找到当前运行时对应的 npm-cli.js，无法自动更新。");
+  }
+
+  const installedPackageBinPath = globalRootCandidates
+    .map((basePath) => path.resolve(basePath, `${packageInfo.name}/bin/codex-switcher.js`))
+    .find((targetPath) => fs.existsSync(targetPath));
+
+  return {
+    nodePath,
+    npmCliPath,
+    reopenBinPath: installedPackageBinPath || path.join(packageRoot, "bin/codex-switcher.js"),
+  };
+}
+
 function sleep(timeoutMs) {
   return new Promise((resolve) => {
     setTimeout(resolve, timeoutMs);
@@ -56,6 +109,7 @@ function buildStatus(payload = {}) {
   const currentVersion = packageInfo.version;
   const latestVersion = payload.latestVersion || currentVersion;
   const hasUpdate = compareVersions(latestVersion, currentVersion) > 0;
+  const autoUpdateState = payload.autoUpdateState || readAutoUpdateState();
 
   return {
     packageName: packageInfo.name,
@@ -66,6 +120,7 @@ function buildStatus(payload = {}) {
     upgradeCommand: `npm install -g ${packageInfo.name}@latest`,
     releaseUrl: `https://www.npmjs.com/package/${packageInfo.name}`,
     lastError: payload.lastError || "",
+    autoUpdateState,
   };
 }
 
@@ -131,44 +186,42 @@ async function getUpdateStatus(options = {}) {
 function scheduleAutoUpdate(options = {}) {
   const reopen = options.reopen !== false;
   const logPath = getAutoUpdateLogPath();
-  const installCommand = `npm install -g ${packageInfo.name}@latest`;
-  const restartCommand = reopen ? " && codex-switcher open" : "";
-
-  if (process.platform === "win32") {
-    const command =
-      `echo [%date% %time%] 开始自动更新 ${packageInfo.name} > "${logPath}" ` +
-      `&& timeout /t ${AUTO_UPDATE_WAIT_SECONDS} /nobreak >nul ` +
-      `&& ${installCommand} >> "${logPath}" 2>&1` +
-      `${restartCommand ? `${restartCommand} >> "${logPath}" 2>&1` : ""}`;
-
-    const child = spawn("cmd.exe", ["/d", "/s", "/c", command], {
-      cwd: os.homedir(),
-      detached: true,
-      stdio: "ignore",
-      windowsHide: true,
-      env: process.env,
-    });
+  const statePath = getAutoUpdateStatePath();
+  const runtimePaths = resolveRuntimePaths();
 
-    child.unref();
-    return {
-      scheduled: true,
+  writeAutoUpdateState({
+    status: "scheduled",
+    packageName: packageInfo.name,
+    requestedVersion: "latest",
+    currentVersion: packageInfo.version,
+    startedAt: new Date().toISOString(),
+    finishedAt: "",
+    logPath,
+    reopen,
+    lastError: "",
+  });
+
+  const payload = Buffer.from(
+    JSON.stringify({
       packageName: packageInfo.name,
       currentVersion: packageInfo.version,
+      parentPid: process.pid,
+      waitSeconds: AUTO_UPDATE_WAIT_SECONDS,
       logPath,
+      statePath,
       reopen,
-    };
-  }
-
-  const command =
-    `sleep ${AUTO_UPDATE_WAIT_SECONDS}; ` +
-    `echo "[auto-update] start ${packageInfo.name}" > "${logPath}"; ` +
-    `${installCommand} >> "${logPath}" 2>&1` +
-    (reopen ? ` && codex-switcher open >> "${logPath}" 2>&1` : "");
-
-  const child = spawn("sh", ["-lc", command], {
+      nodePath: runtimePaths.nodePath,
+      npmCliPath: runtimePaths.npmCliPath,
+      reopenBinPath: runtimePaths.reopenBinPath,
+    }),
+    "utf8",
+  ).toString("base64url");
+
+  const child = spawn(process.execPath, [runnerEntryPath, payload], {
     cwd: os.homedir(),
     detached: true,
     stdio: "ignore",
+    windowsHide: true,
     env: process.env,
   });
 
@@ -178,6 +231,7 @@ function scheduleAutoUpdate(options = {}) {
     packageName: packageInfo.name,
     currentVersion: packageInfo.version,
     logPath,
+    statePath,
     reopen,
   };
 }

package/src/renderer/index.html

@@ -109,6 +109,7 @@
                 <button id="openEndpointStoreButton" class="ghost-button">打开连接数据文件</button>
                 <button id="closeAppButton" class="danger-button">关闭程序</button>
               </div>
+              <div id="appStatusBox" class="status-box info">控制台已就绪。</div>
               <section class="update-strip" aria-label="版本更新状态">
                 <div class="update-copy">
                   <span class="metric-label">版本更新</span>
@@ -116,6 +117,7 @@
                   <span id="updateDetail" class="update-detail">
                     当前版本 -，正在连接 npm 仓库。
                   </span>
+                  <span id="updateHistory" class="update-detail" hidden></span>
                   <code id="updateCommand" class="update-command" hidden>
                     npm install -g codex-endpoint-switcher@latest
                   </code>

package/src/renderer/renderer.js

@@ -30,6 +30,9 @@ function createWebBridge() {
     listEndpoints() {
       return request("/api/endpoints");
     },
+    getEndpoint(payload) {
+      return request(`/api/endpoints/${payload.id}`);
+    },
     getCurrentConfig() {
       return request("/api/current");
     },
@@ -156,8 +159,13 @@ function formatDateTime(value) {
 }
 
 function setStatus(message, type = "info") {
-  void message;
-  void type;
+  const statusBox = $("#appStatusBox");
+  if (!statusBox) {
+    return;
+  }
+
+  statusBox.textContent = message;
+  statusBox.className = `status-box ${type}`;
 }
 
 function setAuthStatus(message, type = "info") {
@@ -310,14 +318,33 @@ function renderUpdateStatus() {
 
   const summary = $("#updateSummary");
   const detail = $("#updateDetail");
+  const history = $("#updateHistory");
   const command = $("#updateCommand");
   const copyButton = $("#copyUpdateCommandButton");
   const autoUpdateButton = $("#autoUpdateButton");
 
-  if (!summary || !detail || !command || !copyButton || !autoUpdateButton) {
+  if (!summary || !detail || !history || !command || !copyButton || !autoUpdateButton) {
     return;
   }
 
+  history.hidden = true;
+  history.textContent = "";
+
+  if (update.autoUpdateState?.status) {
+    const autoUpdateState = update.autoUpdateState;
+    if (autoUpdateState.status === "succeeded") {
+      history.textContent = `上次自动更新已完成：${formatDateTime(autoUpdateState.finishedAt)}`;
+      history.hidden = false;
+    } else if (autoUpdateState.status === "failed") {
+      history.textContent =
+        `上次自动更新失败：${autoUpdateState.lastError || "请查看日志"}。日志：${autoUpdateState.logPath}`;
+      history.hidden = false;
+    } else if (autoUpdateState.status === "running" || autoUpdateState.status === "scheduled") {
+      history.textContent = "检测到自动更新任务正在执行，请稍候。";
+      history.hidden = false;
+    }
+  }
+
   command.textContent = update.upgradeCommand;
 
   if (update.hasUpdate) {
@@ -372,6 +399,23 @@ async function refreshUpdateStatus(force = false) {
   }
 }
 
+async function openEditEndpoint(id, note) {
+  try {
+    setStatus(`正在加载连接：${note} ...`, "info");
+    const endpoint = await bridge.getEndpoint({ id });
+    fillForm(endpoint);
+    openEndpointModal();
+    setStatus(`正在编辑：${note}`, "info");
+  } catch (error) {
+    if (isUnauthorizedError(error)) {
+      await handleAccessRevoked(error.message);
+      return;
+    }
+
+    setStatus(`读取连接失败：${error.message}`, "error");
+  }
+}
+
 function createEndpointCard(endpoint) {
   const card = document.createElement("article");
   card.className = `profile-card ${endpoint.isActive ? "active" : ""}`;
@@ -417,8 +461,7 @@ function createEndpointCard(endpoint) {
   editButton.className = "ghost-button";
   editButton.textContent = "编辑";
   editButton.addEventListener("click", () => {
-    fillForm(endpoint);
-    openEndpointModal();
+    openEditEndpoint(endpoint.id, endpoint.note);
   });
 
   const deleteButton = document.createElement("button");
@@ -793,7 +836,8 @@ async function handleAutoUpdate() {
     summary.textContent = `正在自动更新到 ${update.latestVersion}...`;
   }
   if (detail) {
-    detail.textContent = "程序会先关闭，再自动安装最新 npm 包并重新打开控制台。";
+    detail.textContent =
+      "程序会先关闭，再自动安装最新 npm 包并重新打开控制台。若 10 秒内没有自动关闭，请查看本地更新日志。";
   }
   if (checkButton) {
     checkButton.disabled = true;

package/src/web/server.js

@@ -61,6 +61,14 @@ function createApp() {
     }),
   );
 
+  app.get(
+    "/api/endpoints/:id",
+    wrapAsync(async (req) => {
+      await ensureConsoleAccess();
+      return profileManager.getEndpointById(req.params.id);
+    }),
+  );
+
   app.post(
     "/api/endpoints",
     wrapAsync(async (req) => {
@@ -253,10 +261,11 @@ function createApp() {
 
 function startServer(options = {}) {
   const port = Number(options.port || process.env.PORT || 3186);
+  const host = options.host || process.env.HOST || "127.0.0.1";
   const app = createApp();
   const proxyServer = createProxyServer();
   const proxyPort = profileManager.proxyPort;
-  const webServer = app.listen(port, () => {
+  const webServer = app.listen(port, host, () => {
     const url = `http://localhost:${port}`;
     console.log(`Codex 网页控制台已启动：${url}`);
     console.log(`Codex 热更新代理已启动：${profileManager.proxyBaseUrl}`);
@@ -266,7 +275,7 @@ function startServer(options = {}) {
     }
   });
 
-  proxyServer.listen(proxyPort);
+  proxyServer.listen(proxyPort, host);
   warmUpCurrentTarget().catch(() => {
     // 预热失败不阻断服务启动，真正请求时仍会走自动重试。
   });
@@ -303,7 +312,14 @@ function startServer(options = {}) {
 
   process.removeAllListeners("codex-switcher:shutdown");
   process.on("codex-switcher:shutdown", () => {
+    const forceExitTimer = setTimeout(() => {
+      webServer.closeAllConnections?.();
+      proxyServer.closeAllConnections?.();
+      process.exit(0);
+    }, 2500);
+
     controller.close(() => {
+      clearTimeout(forceExitTimer);
       process.exit(0);
     });
   });