codex-endpoint-switcher 1.0.0 → 1.1.0

package/README.md

@@ -48,6 +48,7 @@ codex-switcher open
 codex-switcher start
 codex-switcher status
 codex-switcher restart
+codex-switcher sync-server
 codex-switcher install-access
 codex-switcher remove-access
 ```
@@ -58,6 +59,7 @@ codex-switcher remove-access
 - `start`：仅在后台启动本地网页服务
 - `status`：查看当前服务状态
 - `restart`：重启本地网页服务
+- `sync-server`：启动账号同步服务，服务端使用 SQLite 单文件数据库
 - `install-access`：创建桌面快捷方式和开机启动项
 - `remove-access`：移除桌面快捷方式和开机启动项
 
@@ -68,3 +70,104 @@ codex-switcher remove-access
 ```text
 http://localhost:3186
 ```
+
+## 账号配置同步
+
+网页控制台现在支持“服务器地址 + 账号 + 密码”的同步方式。
+
+### 1. 启动同步服务
+
+在准备当服务端的机器上执行：
+
+```bash
+codex-switcher sync-server
+```
+
+或者：
+
+```bash
+npm run start:sync-server
+```
+
+默认会监听：
+
+```text
+http://127.0.0.1:3190
+```
+
+默认数据库文件：
+
+```text
+~/.codex-cloud-sync/cloud-sync.db
+```
+
+如果你要让局域网或公网机器访问，可以先设置：
+
+```bash
+set SYNC_SERVER_HOST=0.0.0.0
+set SYNC_SERVER_PORT=3190
+codex-switcher sync-server
+```
+
+### 2. 在网页控制台登录同步账号
+
+在客户端网页控制台里填写：
+
+- 同步服务器地址
+- 账号
+- 密码
+
+然后：
+
+- 第一次使用点 `注册账号`
+- 后续使用点 `登录账号`
+
+### 3. 推送和拉取
+
+- `推送当前连接`：把本机保存的 URL / Key / 备注 上传到账号空间
+- `合并拉取`：把账号空间里的连接合并到本机
+- `覆盖拉取`：直接用账号空间里的连接替换本机连接列表
+
+说明：
+
+- 拉取前会自动备份本机 `~/.codex/endpoint-presets.json` 和 `~/.codex/endpoint-switcher-state.json`
+- 服务端数据库是 SQLite，部署只需要一个 Node 进程和一个 `.db` 文件
+
+## 更新 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/bin/codex-switcher.js

@@ -7,6 +7,7 @@ const { handleCommand } = require("../src/web/launcher");
 const projectRoot = path.resolve(__dirname, "..");
 const installScriptPath = path.join(projectRoot, "install-web-access.ps1");
 const removeScriptPath = path.join(projectRoot, "remove-web-access.ps1");
+const cloudSyncServerPath = path.join(projectRoot, "src/web/cloud-sync-server.js");
 
 function printUsage() {
   console.log(`
@@ -15,6 +16,7 @@ function printUsage() {
   codex-switcher start
   codex-switcher status
   codex-switcher restart
+  codex-switcher sync-server
   codex-switcher install-access
   codex-switcher remove-access
 
@@ -23,6 +25,7 @@ function printUsage() {
   start           仅在后台启动本地网页服务
   status          查看服务状态
   restart         重启本地网页服务
+  sync-server     启动账号同步服务（SQLite）
   install-access  创建桌面快捷方式与开机启动项
   remove-access   删除桌面快捷方式与开机启动项
 `);
@@ -52,6 +55,26 @@ function runPowerShellScript(scriptPath) {
   });
 }
 
+function runNodeScript(scriptPath, extraArgs = []) {
+  return new Promise((resolve, reject) => {
+    const child = spawn(process.execPath, [...extraArgs, scriptPath], {
+      cwd: projectRoot,
+      stdio: "inherit",
+    });
+
+    child.on("exit", (code) => {
+      if (code === 0) {
+        resolve();
+        return;
+      }
+
+      reject(new Error(`脚本执行失败，退出码：${code}`));
+    });
+
+    child.on("error", reject);
+  });
+}
+
 async function main() {
   const command = process.argv[2] || "open";
 
@@ -63,6 +86,10 @@ async function main() {
       await handleCommand(command === "start" ? "ensure" : command);
       return;
     }
+    case "sync-server": {
+      await runNodeScript(cloudSyncServerPath, ["--experimental-sqlite"]);
+      return;
+    }
     case "install-access": {
       await runPowerShellScript(installScriptPath);
       return;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "codex-endpoint-switcher",
-  "version": "1.0.0",
+  "version": "1.1.0",
   "description": "用于切换 Codex URL 和 Key 的本地网页控制台与 npm CLI",
   "main": "src/main/main.js",
   "bin": {
@@ -21,8 +21,13 @@
     "dev": "electron .",
     "start:web": "node src/web/server.js",
     "dev:web": "node src/web/server.js",
+    "start:sync-server": "node --experimental-sqlite src/web/cloud-sync-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/cloud-sync-client.js

@@ -0,0 +1,328 @@
+const fs = require("node:fs/promises");
+const path = require("node:path");
+const os = require("node:os");
+const profileManager = require("./profile-manager");
+
+const codexRoot = path.join(os.homedir(), ".codex");
+const cloudSyncConfigPath = path.join(codexRoot, "cloud-sync-config.json");
+
+function normalizeServerUrl(value) {
+  const raw = String(value || "").trim();
+  if (!raw) {
+    throw new Error("同步服务器地址不能为空。");
+  }
+
+  let parsedUrl;
+  try {
+    parsedUrl = new URL(raw);
+  } catch {
+    throw new Error("同步服务器地址格式不正确。");
+  }
+
+  if (!["http:", "https:"].includes(parsedUrl.protocol)) {
+    throw new Error("同步服务器地址仅支持 http 或 https。");
+  }
+
+  parsedUrl.hash = "";
+  parsedUrl.search = "";
+
+  return parsedUrl.toString().replace(/\/+$/, "");
+}
+
+function normalizeUsername(value) {
+  const username = String(value || "").trim();
+  if (!username) {
+    throw new Error("账号不能为空。");
+  }
+
+  if (username.length < 3 || username.length > 64) {
+    throw new Error("账号长度需要在 3 到 64 个字符之间。");
+  }
+
+  if (/\s/.test(username)) {
+    throw new Error("账号不能包含空白字符。");
+  }
+
+  return username;
+}
+
+function normalizePassword(value) {
+  const password = String(value || "");
+  if (!password.trim()) {
+    throw new Error("密码不能为空。");
+  }
+
+  if (password.length < 6) {
+    throw new Error("密码至少需要 6 位。");
+  }
+
+  return password;
+}
+
+async function ensureStorage() {
+  await fs.mkdir(codexRoot, { recursive: true });
+
+  try {
+    await fs.access(cloudSyncConfigPath);
+  } catch {
+    await fs.writeFile(
+      cloudSyncConfigPath,
+      `${JSON.stringify(
+        {
+          serverUrl: "",
+          username: "",
+          authToken: "",
+          tokenExpiresAt: "",
+          lastPushAt: "",
+          lastPullAt: "",
+        },
+        null,
+        2,
+      )}\n`,
+      "utf8",
+    );
+  }
+}
+
+async function readConfig() {
+  await ensureStorage();
+  const content = await fs.readFile(cloudSyncConfigPath, "utf8");
+  const config = JSON.parse(content);
+
+  return {
+    serverUrl: String(config.serverUrl || "").trim(),
+    username: String(config.username || "").trim(),
+    authToken: String(config.authToken || "").trim(),
+    tokenExpiresAt: String(config.tokenExpiresAt || "").trim(),
+    lastPushAt: String(config.lastPushAt || "").trim(),
+    lastPullAt: String(config.lastPullAt || "").trim(),
+  };
+}
+
+async function writeConfig(config) {
+  await ensureStorage();
+  await fs.writeFile(cloudSyncConfigPath, `${JSON.stringify(config, null, 2)}\n`, "utf8");
+}
+
+async function requestJson(serverUrl, pathname, options = {}) {
+  const targetUrl = new URL(pathname, `${serverUrl}/`);
+  const response = await fetch(targetUrl, {
+    method: options.method || "GET",
+    headers: {
+      "Content-Type": "application/json",
+      ...(options.authToken
+        ? {
+            Authorization: `Bearer ${options.authToken}`,
+          }
+        : {}),
+    },
+    body: options.body ? JSON.stringify(options.body) : undefined,
+    signal: AbortSignal.timeout(options.timeoutMs || 5000),
+  });
+
+  const rawText = await response.text();
+  let payload = {};
+
+  try {
+    payload = rawText ? JSON.parse(rawText) : {};
+  } catch {
+    payload = {};
+  }
+
+  if (!response.ok || payload.ok === false) {
+    throw new Error(payload.error || `请求同步服务失败：${response.status}`);
+  }
+
+  return payload.data;
+}
+
+async function getCloudSyncStatus() {
+  const config = await readConfig();
+  const result = {
+    configPath: cloudSyncConfigPath,
+    serverUrl: config.serverUrl,
+    username: config.username,
+    hasToken: Boolean(config.authToken),
+    loggedIn: false,
+    tokenExpiresAt: config.tokenExpiresAt,
+    lastPushAt: config.lastPushAt,
+    lastPullAt: config.lastPullAt,
+    remoteUser: "",
+    remoteProfileUpdatedAt: "",
+    lastError: "",
+  };
+
+  if (!config.serverUrl || !config.authToken) {
+    return result;
+  }
+
+  try {
+    const data = await requestJson(config.serverUrl, "/api/auth/me", {
+      authToken: config.authToken,
+      timeoutMs: 3000,
+    });
+
+    return {
+      ...result,
+      loggedIn: true,
+      username: data.user.username,
+      remoteUser: data.user.username,
+      tokenExpiresAt: data.session.expiresAt,
+      remoteProfileUpdatedAt: data.syncProfileUpdatedAt || "",
+      lastError: "",
+    };
+  } catch (error) {
+    return {
+      ...result,
+      lastError: error instanceof Error ? error.message : String(error),
+    };
+  }
+}
+
+async function authenticate(mode, payload) {
+  const serverUrl = normalizeServerUrl(payload.serverUrl);
+  const username = normalizeUsername(payload.username);
+  const password = normalizePassword(payload.password);
+  const endpointPath = mode === "register" ? "/api/auth/register" : "/api/auth/login";
+  const response = await requestJson(serverUrl, endpointPath, {
+    method: "POST",
+    body: {
+      username,
+      password,
+    },
+  });
+
+  await writeConfig({
+    serverUrl,
+    username: response.user.username,
+    authToken: String(response.token || "").trim(),
+    tokenExpiresAt: String(response.expiresAt || "").trim(),
+    lastPushAt: "",
+    lastPullAt: "",
+  });
+
+  return {
+    ...(await getCloudSyncStatus()),
+    message: mode === "register" ? "账号注册并登录成功。" : "账号登录成功。",
+  };
+}
+
+async function registerAccount(payload) {
+  return authenticate("register", payload);
+}
+
+async function loginAccount(payload) {
+  return authenticate("login", payload);
+}
+
+async function logoutAccount() {
+  const config = await readConfig();
+
+  if (config.serverUrl && config.authToken) {
+    try {
+      await requestJson(config.serverUrl, "/api/auth/logout", {
+        method: "POST",
+        authToken: config.authToken,
+        timeoutMs: 3000,
+      });
+    } catch {
+      // 服务端不可达时，本地仍然允许清理登录态，避免用户被卡住。
+    }
+  }
+
+  await writeConfig({
+    ...config,
+    authToken: "",
+    tokenExpiresAt: "",
+  });
+
+  return {
+    ...(await getCloudSyncStatus()),
+    message: "已退出账号同步登录。",
+  };
+}
+
+async function requireLoggedInConfig() {
+  const config = await readConfig();
+  if (!config.serverUrl) {
+    throw new Error("请先填写并登录同步服务器。");
+  }
+
+  if (!config.authToken) {
+    throw new Error("当前还没有登录同步账号。");
+  }
+
+  return config;
+}
+
+/**
+ * 把当前本机保存的连接配置推送到远端账号空间。
+ */
+async function pushCurrentConfig() {
+  const config = await requireLoggedInConfig();
+  const exported = await profileManager.exportSyncPackage();
+  const response = await requestJson(config.serverUrl, "/api/sync/config", {
+    method: "PUT",
+    authToken: config.authToken,
+    body: {
+      syncCode: exported.syncCode,
+      endpointCount: exported.endpointCount,
+    },
+  });
+
+  const nextConfig = {
+    ...config,
+    lastPushAt: String(response.updatedAt || new Date().toISOString()).trim(),
+  };
+  await writeConfig(nextConfig);
+
+  return {
+    ...(await getCloudSyncStatus()),
+    endpointCount: exported.endpointCount,
+    remoteUpdatedAt: response.updatedAt,
+    message: `已把 ${exported.endpointCount} 条连接推送到账号空间。`,
+  };
+}
+
+/**
+ * 从远端账号空间拉取连接配置，再按指定策略导入到本机。
+ */
+async function pullRemoteConfig(mode = "merge") {
+  const safeMode = String(mode || "merge").trim().toLowerCase();
+  if (!["merge", "replace"].includes(safeMode)) {
+    throw new Error("拉取模式不正确，只支持 merge 或 replace。");
+  }
+
+  const config = await requireLoggedInConfig();
+  const response = await requestJson(config.serverUrl, "/api/sync/config", {
+    method: "GET",
+    authToken: config.authToken,
+  });
+  const importResult = await profileManager.importSyncPackage(response.syncCode, safeMode);
+  const nextConfig = {
+    ...config,
+    lastPullAt: new Date().toISOString(),
+  };
+  await writeConfig(nextConfig);
+
+  return {
+    ...(await getCloudSyncStatus()),
+    ...importResult,
+    remoteUpdatedAt: response.updatedAt,
+    endpointCount: response.endpointCount,
+    message:
+      safeMode === "merge"
+        ? "已从账号空间拉取并合并到本机。"
+        : "已从账号空间拉取并覆盖本机连接列表。",
+  };
+}
+
+module.exports = {
+  cloudSyncConfigPath,
+  getCloudSyncStatus,
+  loginAccount,
+  logoutAccount,
+  pullRemoteConfig,
+  pushCurrentConfig,
+  registerAccount,
+};

package/src/main/main.js

@@ -1,6 +1,7 @@
 const path = require("node:path");
 const { app, BrowserWindow, ipcMain, shell } = require("electron");
 const profileManager = require("./profile-manager");
+const cloudSyncClient = require("./cloud-sync-client");
 
 function createWindow() {
   const mainWindow = new BrowserWindow({
@@ -46,6 +47,42 @@ function registerHandlers() {
     return profileManager.switchEndpoint(payload.id);
   });
 
+  ipcMain.handle("proxy:enable", async () => {
+    return profileManager.enableProxyMode();
+  });
+
+  ipcMain.handle("sync:export", async () => {
+    return profileManager.exportSyncPackage();
+  });
+
+  ipcMain.handle("sync:import", async (_event, payload) => {
+    return profileManager.importSyncPackage(payload.syncCode, payload.mode);
+  });
+
+  ipcMain.handle("cloud:status", async () => {
+    return cloudSyncClient.getCloudSyncStatus();
+  });
+
+  ipcMain.handle("cloud:register", async (_event, payload) => {
+    return cloudSyncClient.registerAccount(payload);
+  });
+
+  ipcMain.handle("cloud:login", async (_event, payload) => {
+    return cloudSyncClient.loginAccount(payload);
+  });
+
+  ipcMain.handle("cloud:logout", async () => {
+    return cloudSyncClient.logoutAccount();
+  });
+
+  ipcMain.handle("cloud:push", async () => {
+    return cloudSyncClient.pushCurrentConfig();
+  });
+
+  ipcMain.handle("cloud:pull", async (_event, payload) => {
+    return cloudSyncClient.pullRemoteConfig(payload.mode);
+  });
+
   ipcMain.handle("paths:get", async () => {
     return profileManager.getManagedPaths();
   });

package/src/main/preload.js

@@ -19,6 +19,33 @@ contextBridge.exposeInMainWorld("codexDesktop", {
   switchEndpoint(payload) {
     return ipcRenderer.invoke("endpoints:switch", payload);
   },
+  enableProxyMode() {
+    return ipcRenderer.invoke("proxy:enable");
+  },
+  exportSyncCode() {
+    return ipcRenderer.invoke("sync:export");
+  },
+  importSyncCode(payload) {
+    return ipcRenderer.invoke("sync:import", payload);
+  },
+  getCloudSyncStatus() {
+    return ipcRenderer.invoke("cloud:status");
+  },
+  registerCloudAccount(payload) {
+    return ipcRenderer.invoke("cloud:register", payload);
+  },
+  loginCloudAccount(payload) {
+    return ipcRenderer.invoke("cloud:login", payload);
+  },
+  logoutCloudAccount() {
+    return ipcRenderer.invoke("cloud:logout");
+  },
+  pushCloudConfig() {
+    return ipcRenderer.invoke("cloud:push");
+  },
+  pullCloudConfig(payload) {
+    return ipcRenderer.invoke("cloud:pull", payload);
+  },
   getPaths() {
     return ipcRenderer.invoke("paths:get");
   },