codex-endpoint-switcher 1.0.0

package/src/web/launcher.js

@@ -0,0 +1,248 @@
+const fs = require("node:fs");
+const path = require("node:path");
+const http = require("node:http");
+const { exec, spawn } = require("node:child_process");
+
+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 healthUrl = `http://127.0.0.1:${port}/api/health`;
+const consoleUrl = `http://localhost:${port}`;
+
+function ensureRuntimeDir() {
+  fs.mkdirSync(runtimeDir, { recursive: true });
+}
+
+function requestJson(url, timeoutMs = 1200) {
+  return new Promise((resolve, reject) => {
+    const request = http.get(url, (response) => {
+      let data = "";
+      response.setEncoding("utf8");
+      response.on("data", (chunk) => {
+        data += chunk;
+      });
+      response.on("end", () => {
+        try {
+          resolve(JSON.parse(data));
+        } catch (error) {
+          reject(error);
+        }
+      });
+    });
+
+    request.setTimeout(timeoutMs, () => {
+      request.destroy(new Error("请求超时"));
+    });
+
+    request.on("error", reject);
+  });
+}
+
+/**
+ * 检查本地网页服务是否已经可用。
+ */
+async function checkServerHealth() {
+  try {
+    const payload = await requestJson(healthUrl);
+    return Boolean(payload && payload.ok);
+  } catch {
+    return false;
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+async function waitForServer(maxWaitMs = 20000) {
+  const startedAt = Date.now();
+
+  while (Date.now() - startedAt < maxWaitMs) {
+    if (await checkServerHealth()) {
+      return true;
+    }
+
+    await sleep(500);
+  }
+
+  return false;
+}
+
+/**
+ * 以脱离终端的方式启动本地网页服务。
+ */
+function spawnServerInBackground() {
+  ensureRuntimeDir();
+  const stdoutPath = path.join(runtimeDir, "web-server.out.log");
+  const stderrPath = path.join(runtimeDir, "web-server.err.log");
+  const stdoutFd = fs.openSync(stdoutPath, "a");
+  const stderrFd = fs.openSync(stderrPath, "a");
+
+  const child = spawn(process.execPath, [serverEntryPath], {
+    cwd: projectRoot,
+    detached: true,
+    stdio: ["ignore", stdoutFd, stderrFd],
+    env: {
+      ...process.env,
+      AUTO_OPEN_BROWSER: "false",
+      PORT: String(port),
+    },
+  });
+
+  child.unref();
+  return child.pid;
+}
+
+async function ensureServerRunning() {
+  if (await checkServerHealth()) {
+    return {
+      started: false,
+      running: true,
+      url: consoleUrl,
+      port,
+    };
+  }
+
+  const pid = spawnServerInBackground();
+  const ready = await waitForServer();
+
+  if (!ready) {
+    throw new Error("本地网页服务启动失败，请检查 runtime 日志。");
+  }
+
+  return {
+    started: true,
+    running: true,
+    url: consoleUrl,
+    port,
+    pid,
+  };
+}
+
+function openBrowser(url) {
+  return new Promise((resolve, reject) => {
+    exec(`cmd /c start "" "${url}"`, (error) => {
+      if (error) {
+        reject(error);
+        return;
+      }
+
+      resolve();
+    });
+  });
+}
+
+function getListeningPid() {
+  return new Promise((resolve, reject) => {
+    exec(`cmd /c netstat -ano | findstr :${port}`, (error, stdout) => {
+      if (error) {
+        resolve(null);
+        return;
+      }
+
+      const lines = stdout
+        .split(/\r?\n/)
+        .map((line) => line.trim())
+        .filter(Boolean);
+
+      for (const line of lines) {
+        const parts = line.split(/\s+/);
+        const state = parts[3];
+        const pid = Number(parts[4]);
+        if (state === "LISTENING" && Number.isFinite(pid)) {
+          resolve(pid);
+          return;
+        }
+      }
+
+      resolve(null);
+    });
+  });
+}
+
+async function restartServer() {
+  const pid = await getListeningPid();
+  if (pid) {
+    await new Promise((resolve, reject) => {
+      exec(`cmd /c taskkill /PID ${pid} /F`, (error) => {
+        if (error) {
+          reject(error);
+          return;
+        }
+
+        resolve();
+      });
+    });
+    await sleep(800);
+  }
+
+  return ensureServerRunning();
+}
+
+async function handleCommand(command) {
+  switch (command) {
+    case "ensure":
+    case "start": {
+      const result = await ensureServerRunning();
+      console.log(JSON.stringify(result, null, 2));
+      return;
+    }
+    case "open": {
+      const result = await ensureServerRunning();
+      await openBrowser(result.url);
+      console.log(
+        JSON.stringify(
+          {
+            ...result,
+            opened: true,
+          },
+          null,
+          2,
+        ),
+      );
+      return;
+    }
+    case "status": {
+      const running = await checkServerHealth();
+      console.log(
+        JSON.stringify(
+          {
+            running,
+            url: consoleUrl,
+            port,
+          },
+          null,
+          2,
+        ),
+      );
+      return;
+    }
+    case "restart": {
+      const result = await restartServer();
+      console.log(JSON.stringify({ ...result, restarted: true }, null, 2));
+      return;
+    }
+    default:
+      throw new Error("不支持的命令。可用命令：ensure、open、status、restart");
+  }
+}
+
+if (require.main === module) {
+  const command = process.argv[2] || "status";
+  handleCommand(command).catch((error) => {
+    console.error(error instanceof Error ? error.message : String(error));
+    process.exit(1);
+  });
+}
+
+module.exports = {
+  checkServerHealth,
+  ensureServerRunning,
+  handleCommand,
+  restartServer,
+  openBrowser,
+  runtimeDir,
+  consoleUrl,
+  port,
+};

package/src/web/server.js

@@ -0,0 +1,132 @@
+const path = require("node:path");
+const { exec } = require("node:child_process");
+const express = require("express");
+const profileManager = require("../main/profile-manager");
+
+function wrapAsync(handler) {
+  return async (req, res) => {
+    try {
+      const data = await handler(req, res);
+      res.json({ ok: true, data });
+    } catch (error) {
+      res.status(400).json({
+        ok: false,
+        error: error instanceof Error ? error.message : String(error),
+      });
+    }
+  };
+}
+
+function createApp() {
+  const app = express();
+  const rendererRoot = path.join(__dirname, "../renderer");
+
+  app.use(express.json({ limit: "2mb" }));
+  app.use(express.static(rendererRoot));
+
+  app.get("/api/health", (_req, res) => {
+    res.json({ ok: true, data: { status: "ok" } });
+  });
+
+  app.get(
+    "/api/current",
+    wrapAsync(async () => {
+      return profileManager.getCurrentEndpointSummary();
+    }),
+  );
+
+  app.get(
+    "/api/endpoints",
+    wrapAsync(async () => {
+      return profileManager.listEndpoints();
+    }),
+  );
+
+  app.post(
+    "/api/endpoints",
+    wrapAsync(async (req) => {
+      return profileManager.createEndpoint(req.body);
+    }),
+  );
+
+  app.put(
+    "/api/endpoints/:id",
+    wrapAsync(async (req) => {
+      return profileManager.updateEndpoint(req.params.id, req.body);
+    }),
+  );
+
+  app.delete(
+    "/api/endpoints/:id",
+    wrapAsync(async (req) => {
+      return profileManager.deleteEndpoint(req.params.id);
+    }),
+  );
+
+  app.post(
+    "/api/endpoints/switch",
+    wrapAsync(async (req) => {
+      return profileManager.switchEndpoint(req.body.id);
+    }),
+  );
+
+  app.get(
+    "/api/paths",
+    wrapAsync(async () => {
+      return profileManager.getManagedPaths();
+    }),
+  );
+
+  app.post(
+    "/api/open-path",
+    wrapAsync(async (req) => {
+      const targetPath = String(req.body.targetPath || "").trim();
+      if (!targetPath) {
+        throw new Error("缺少要打开的路径。");
+      }
+
+      await new Promise((resolve, reject) => {
+        exec(`cmd /c start "" "${targetPath}"`, (error) => {
+          if (error) {
+            reject(error);
+            return;
+          }
+
+          resolve();
+        });
+      });
+
+      return { targetPath };
+    }),
+  );
+
+  app.get("/{*any}", (_req, res) => {
+    res.sendFile(path.join(rendererRoot, "index.html"));
+  });
+
+  return app;
+}
+
+function startServer(options = {}) {
+  const port = Number(options.port || process.env.PORT || 3186);
+  const app = createApp();
+  const server = app.listen(port, () => {
+    const url = `http://localhost:${port}`;
+    console.log(`Codex 网页控制台已启动：${url}`);
+
+    if (options.autoOpen !== false && process.env.AUTO_OPEN_BROWSER !== "false") {
+      exec(`cmd /c start "" "${url}"`);
+    }
+  });
+
+  return server;
+}
+
+if (require.main === module) {
+  startServer();
+}
+
+module.exports = {
+  createApp,
+  startServer,
+};

package/start-web-background.cmd

@@ -0,0 +1,3 @@
+@echo off
+cd /d "%~dp0"
+node src\web\launcher.js ensure

package/start-web-background.vbs

@@ -0,0 +1,2 @@
+Set shell = CreateObject("WScript.Shell")
+shell.Run "cmd /c """ & Replace(WScript.ScriptFullName, "start-web-background.vbs", "start-web-background.cmd") & """", 0, False