codex-endpoint-switcher 1.0.1 → 1.1.0

package/src/main/profile-manager.js

@@ -11,6 +11,7 @@ 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}/`;
+const syncCodePrefix = "ces1:";
 
 function escapeRegExp(value) {
   return value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
@@ -79,6 +80,123 @@ function validateEndpointPayload(payload) {
   return { note, url, key };
 }
 
+function normalizeTimestamp(value, fallbackValue) {
+  const raw = String(value || "").trim();
+  if (!raw) {
+    return fallbackValue;
+  }
+
+  const parsed = new Date(raw);
+  if (Number.isNaN(parsed.getTime())) {
+    return fallbackValue;
+  }
+
+  return parsed.toISOString();
+}
+
+function encodeSyncCode(payload) {
+  return `${syncCodePrefix}${Buffer.from(JSON.stringify(payload), "utf8").toString("base64url")}`;
+}
+
+function decodeSyncCode(syncCode) {
+  const input = String(syncCode || "").trim();
+  if (!input) {
+    throw new Error("同步码不能为空。");
+  }
+
+  if (input.startsWith("{")) {
+    return JSON.parse(input);
+  }
+
+  if (input.startsWith(syncCodePrefix)) {
+    const encoded = input.slice(syncCodePrefix.length).trim();
+    if (!encoded) {
+      throw new Error("同步码格式不正确。");
+    }
+
+    return JSON.parse(Buffer.from(encoded, "base64url").toString("utf8"));
+  }
+
+  throw new Error("同步码格式不正确。请使用系统生成的同步码，或粘贴 JSON 内容。");
+}
+
+function normalizeSyncPayload(payload) {
+  if (!payload || typeof payload !== "object" || Array.isArray(payload)) {
+    throw new Error("同步数据格式不正确。");
+  }
+
+  const schemaVersion = Number(payload.schemaVersion || payload.version || 0);
+  if (schemaVersion !== 1) {
+    throw new Error("当前只支持导入 v1 同步数据。");
+  }
+
+  const rawEndpoints = Array.isArray(payload.endpoints) ? payload.endpoints : [];
+  if (rawEndpoints.length === 0) {
+    throw new Error("同步数据里没有可导入的连接。");
+  }
+
+  const usedIds = new Set();
+  const endpoints = rawEndpoints.map((item) => {
+    const normalized = validateEndpointPayload(item);
+    const fallbackTimestamp = new Date().toISOString();
+    let id = String(item.id || "").trim();
+
+    if (!id || usedIds.has(id)) {
+      id = randomUUID();
+    }
+
+    usedIds.add(id);
+
+    return {
+      id,
+      note: normalized.note,
+      url: normalized.url,
+      key: normalized.key,
+      createdAt: normalizeTimestamp(item.createdAt, fallbackTimestamp),
+      updatedAt: normalizeTimestamp(item.updatedAt, fallbackTimestamp),
+    };
+  });
+
+  return {
+    schemaVersion,
+    exportedAt: normalizeTimestamp(payload.exportedAt, new Date().toISOString()),
+    activeEndpointId: String(payload.activeEndpointId || "").trim(),
+    endpoints,
+  };
+}
+
+function buildSyncPayload(endpoints, activeEndpointId) {
+  return {
+    schemaVersion: 1,
+    exportedAt: new Date().toISOString(),
+    source: "codex-endpoint-switcher",
+    activeEndpointId: String(activeEndpointId || "").trim(),
+    endpoints: endpoints.map((endpoint) => ({
+      id: endpoint.id,
+      note: endpoint.note,
+      url: endpoint.url,
+      key: endpoint.key,
+      createdAt: endpoint.createdAt,
+      updatedAt: endpoint.updatedAt,
+    })),
+  };
+}
+
+function findEndpointMatchIndex(endpoints, importedEndpoint) {
+  const byId = endpoints.findIndex((item) => item.id === importedEndpoint.id);
+  if (byId !== -1) {
+    return byId;
+  }
+
+  return endpoints.findIndex(
+    (item) => item.note === importedEndpoint.note && item.url === importedEndpoint.url,
+  );
+}
+
+function resolveImportedEndpointId(endpoints, importedId) {
+  return endpoints.find((item) => item.id === importedId)?.id || "";
+}
+
 async function ensureDirectory(targetPath) {
   await fs.mkdir(targetPath, { recursive: true });
 }
@@ -302,6 +420,26 @@ async function backupCurrentState() {
   };
 }
 
+async function backupEndpointData() {
+  const timestamp = new Date().toISOString().replace(/[:.]/g, "-");
+  const endpointStoreBackupPath = path.join(
+    backupDir,
+    `endpoint-presets.json.sync-${timestamp}.bak`,
+  );
+  const endpointStateBackupPath = path.join(
+    backupDir,
+    `endpoint-switcher-state.json.sync-${timestamp}.bak`,
+  );
+
+  await fs.copyFile(endpointStorePath, endpointStoreBackupPath);
+  await fs.copyFile(endpointStatePath, endpointStateBackupPath);
+
+  return {
+    endpointStoreBackupPath,
+    endpointStateBackupPath,
+  };
+}
+
 function buildEndpointResponse(endpoint, activeId) {
   return {
     id: endpoint.id,
@@ -582,6 +720,114 @@ async function enableProxyMode() {
   };
 }
 
+/**
+ * 导出当前保存的连接为可跨机器粘贴传输的同步码。
+ */
+async function exportSyncPackage() {
+  const context = await resolveActiveEndpointContext();
+  const payload = buildSyncPayload(context.endpoints, context.activeEndpointId);
+
+  return {
+    syncCode: encodeSyncCode(payload),
+    exportedAt: payload.exportedAt,
+    endpointCount: payload.endpoints.length,
+    activeEndpointId: payload.activeEndpointId,
+    endpoints: context.endpoints.map((item) => ({
+      id: item.id,
+      note: item.note,
+      url: item.url,
+      maskedKey: maskKey(item.key),
+      isActive: item.id === context.activeEndpointId,
+    })),
+  };
+}
+
+/**
+ * 导入同步码，支持合并现有连接或直接覆盖本机连接列表。
+ */
+async function importSyncPackage(syncCode, mode = "merge") {
+  const safeMode = String(mode || "merge").trim().toLowerCase();
+  if (!["merge", "replace"].includes(safeMode)) {
+    throw new Error("导入模式不正确，只支持 merge 或 replace。");
+  }
+
+  const importedPayload = normalizeSyncPayload(decodeSyncCode(syncCode));
+  const [existingEndpoints, existingState] = await Promise.all([
+    readEndpointStore(),
+    readEndpointState(),
+  ]);
+
+  const workingEndpoints = safeMode === "replace" ? [] : existingEndpoints.slice();
+  const importIdMapping = new Map();
+  let addedCount = 0;
+  let updatedCount = 0;
+
+  for (const importedEndpoint of importedPayload.endpoints) {
+    const matchIndex = findEndpointMatchIndex(workingEndpoints, importedEndpoint);
+
+    if (matchIndex !== -1) {
+      const currentEndpoint = workingEndpoints[matchIndex];
+      workingEndpoints[matchIndex] = {
+        ...currentEndpoint,
+        note: importedEndpoint.note,
+        url: importedEndpoint.url,
+        key: importedEndpoint.key,
+        createdAt: currentEndpoint.createdAt || importedEndpoint.createdAt,
+        updatedAt: importedEndpoint.updatedAt,
+      };
+      importIdMapping.set(importedEndpoint.id, workingEndpoints[matchIndex].id);
+      updatedCount += 1;
+      continue;
+    }
+
+    let nextId = importedEndpoint.id;
+    while (resolveImportedEndpointId(workingEndpoints, nextId)) {
+      nextId = randomUUID();
+    }
+
+    const nextEndpoint = {
+      ...importedEndpoint,
+      id: nextId,
+    };
+
+    workingEndpoints.push(nextEndpoint);
+    importIdMapping.set(importedEndpoint.id, nextEndpoint.id);
+    addedCount += 1;
+  }
+
+  const currentActiveStillExists = workingEndpoints.some(
+    (item) => item.id === existingState.activeEndpointId,
+  );
+  const importedActiveId = importIdMapping.get(importedPayload.activeEndpointId) || "";
+  const nextActiveId = currentActiveStillExists
+    ? existingState.activeEndpointId
+    : importedActiveId || (workingEndpoints[0] ? workingEndpoints[0].id : "");
+  const activeEndpoint = workingEndpoints.find((item) => item.id === nextActiveId) || null;
+
+  const backupPaths = await backupEndpointData();
+  await writeEndpointStore(workingEndpoints);
+  await writeEndpointState({
+    activeEndpointId: nextActiveId,
+    proxyModeEnabled: existingState.proxyModeEnabled,
+  });
+
+  return {
+    ...backupPaths,
+    mode: safeMode,
+    importedCount: importedPayload.endpoints.length,
+    addedCount,
+    updatedCount,
+    totalEndpoints: workingEndpoints.length,
+    activeEndpointId: nextActiveId,
+    activeEndpointNote: activeEndpoint ? activeEndpoint.note : "",
+    importedActiveApplied: Boolean(importedActiveId && importedActiveId === nextActiveId),
+    message:
+      safeMode === "merge"
+        ? "已合并导入同步数据。当前连接不会被强制切换，除非原当前连接已不存在。"
+        : "已覆盖本机连接列表。若原当前连接已不存在，则会切到同步数据里的当前连接。",
+  };
+}
+
 function getManagedPaths() {
   return {
     codexRoot,
@@ -616,9 +862,11 @@ module.exports = {
   createEndpoint,
   deleteEndpoint,
   enableProxyMode,
+  exportSyncPackage,
   getCurrentEndpointSummary,
   getManagedPaths,
   getProxyTarget,
+  importSyncPackage,
   listEndpoints,
   proxyBaseUrl,
   proxyPort,

package/src/renderer/index.html

@@ -122,6 +122,77 @@
               <button id="clearFormButton" type="button" class="ghost-button">清空表单</button>
             </div>
           </form>
+
+          <div class="stack-form stack-form-alt">
+            <div>
+              <p class="panel-kicker">Cloud Sync</p>
+              <h3>账号配置同步</h3>
+            </div>
+            <label class="field">
+              <span>同步服务器</span>
+              <input
+                id="cloudServerUrl"
+                type="text"
+                placeholder="例如：http://127.0.0.1:3190"
+                autocomplete="off"
+              />
+            </label>
+            <label class="field">
+              <span>账号</span>
+              <input
+                id="cloudUsername"
+                type="text"
+                placeholder="例如：yourname"
+                autocomplete="off"
+              />
+            </label>
+            <label class="field">
+              <span>密码</span>
+              <input
+                id="cloudPassword"
+                type="password"
+                placeholder="输入同步账号密码"
+                autocomplete="off"
+              />
+            </label>
+            <p class="field-hint">
+              账号空间里保存的是你的连接配置。推送是把本机连接上传到账号，拉取是把账号里的连接同步回本机。
+            </p>
+            <div class="sync-status-grid">
+              <article class="sync-status-card">
+                <span class="metric-label">登录状态</span>
+                <strong id="cloudAuthStatus">未登录</strong>
+              </article>
+              <article class="sync-status-card">
+                <span class="metric-label">服务器</span>
+                <strong id="cloudRemoteStatus">未设置</strong>
+              </article>
+              <article class="sync-status-card sync-status-card-wide">
+                <span class="metric-label">同步记录</span>
+                <strong id="cloudLastSyncStatus">还没有推送或拉取记录</strong>
+              </article>
+            </div>
+            <div class="action-row">
+              <button id="cloudRegisterButton" type="button" class="secondary-button">
+                注册账号
+              </button>
+              <button id="cloudLoginButton" type="button" class="primary-button">
+                登录账号
+              </button>
+              <button id="cloudLogoutButton" type="button" class="ghost-button">退出登录</button>
+            </div>
+            <div class="action-row">
+              <button id="cloudPushButton" type="button" class="secondary-button">
+                推送当前连接
+              </button>
+              <button id="cloudPullMergeButton" type="button" class="primary-button">
+                合并拉取
+              </button>
+              <button id="cloudPullReplaceButton" type="button" class="danger-button">
+                覆盖拉取
+              </button>
+            </div>
+          </div>
         </section>
 
         <section class="panel profiles-panel">

package/src/renderer/renderer.js

@@ -2,6 +2,7 @@ const state = {
   current: null,
   endpoints: [],
   paths: null,
+  cloud: null,
 };
 
 function createWebBridge() {
@@ -56,6 +57,37 @@ function createWebBridge() {
         method: "POST",
       });
     },
+    getCloudSyncStatus() {
+      return request("/api/cloud/status");
+    },
+    registerCloudAccount(payload) {
+      return request("/api/cloud/register", {
+        method: "POST",
+        body: JSON.stringify(payload),
+      });
+    },
+    loginCloudAccount(payload) {
+      return request("/api/cloud/login", {
+        method: "POST",
+        body: JSON.stringify(payload),
+      });
+    },
+    logoutCloudAccount() {
+      return request("/api/cloud/logout", {
+        method: "POST",
+      });
+    },
+    pushCloudConfig() {
+      return request("/api/cloud/push", {
+        method: "POST",
+      });
+    },
+    pullCloudConfig(payload) {
+      return request("/api/cloud/pull", {
+        method: "POST",
+        body: JSON.stringify(payload),
+      });
+    },
     getPaths() {
       return request("/api/paths");
     },
@@ -96,6 +128,19 @@ function setStatus(message, type = "info") {
   statusBox.className = `status-box ${type}`;
 }
 
+function syncFieldValue(selector, value) {
+  const input = $(selector);
+  if (!input) {
+    return;
+  }
+
+  if (document.activeElement === input && String(input.value || "").trim()) {
+    return;
+  }
+
+  input.value = value || "";
+}
+
 function resetForm() {
   $("#endpointId").value = "";
   $("#endpointNote").value = "";
@@ -140,6 +185,49 @@ function renderCurrent() {
     : "当前未匹配到已保存连接";
 }
 
+function renderCloudStatus() {
+  const cloud = state.cloud;
+  if (!cloud) {
+    return;
+  }
+
+  syncFieldValue("#cloudServerUrl", cloud.serverUrl);
+  syncFieldValue("#cloudUsername", cloud.username);
+
+  const authText = !cloud.serverUrl
+    ? "未配置同步服务器"
+    : cloud.loggedIn
+      ? `已登录：${cloud.remoteUser || cloud.username}`
+      : cloud.hasToken
+        ? "本地已保存登录态，但远端校验未通过"
+        : "未登录";
+
+  const remoteText = cloud.serverUrl
+    ? cloud.lastError
+      ? `${cloud.serverUrl} · ${cloud.lastError}`
+      : cloud.serverUrl
+    : "未设置";
+
+  const syncStatusParts = [];
+  if (cloud.lastPushAt) {
+    syncStatusParts.push(`最近推送：${formatDateTime(cloud.lastPushAt)}`);
+  }
+  if (cloud.lastPullAt) {
+    syncStatusParts.push(`最近拉取：${formatDateTime(cloud.lastPullAt)}`);
+  }
+  if (!syncStatusParts.length) {
+    syncStatusParts.push("还没有推送或拉取记录");
+  }
+
+  $("#cloudAuthStatus").textContent = authText;
+  $("#cloudRemoteStatus").textContent = remoteText;
+  $("#cloudLastSyncStatus").textContent = syncStatusParts.join(" / ");
+  $("#cloudLogoutButton").disabled = !cloud.hasToken;
+  $("#cloudPushButton").disabled = !cloud.loggedIn;
+  $("#cloudPullMergeButton").disabled = !cloud.loggedIn;
+  $("#cloudPullReplaceButton").disabled = !cloud.loggedIn;
+}
+
 function createEndpointCard(endpoint) {
   const card = document.createElement("article");
   card.className = `profile-card ${endpoint.isActive ? "active" : ""}`;
@@ -230,18 +318,21 @@ function renderEndpoints() {
 
 async function refreshDashboard(showMessage = true) {
   try {
-    const [current, endpoints, paths] = await Promise.all([
+    const [current, endpoints, paths, cloud] = await Promise.all([
       bridge.getCurrentConfig(),
       bridge.listEndpoints(),
       bridge.getPaths(),
+      bridge.getCloudSyncStatus(),
     ]);
 
     state.current = current;
     state.endpoints = endpoints;
     state.paths = paths;
+    state.cloud = cloud;
 
     renderCurrent();
     renderEndpoints();
+    renderCloudStatus();
 
     if (showMessage) {
       setStatus("已刷新当前连接状态。", "success");
@@ -289,6 +380,91 @@ async function handleEnableProxyMode() {
   }
 }
 
+function getCloudFormPayload() {
+  return {
+    serverUrl: $("#cloudServerUrl").value.trim(),
+    username: $("#cloudUsername").value.trim(),
+    password: $("#cloudPassword").value,
+  };
+}
+
+async function handleCloudRegister() {
+  try {
+    setStatus("正在注册同步账号 ...", "info");
+    const payload = getCloudFormPayload();
+    const result = await bridge.registerCloudAccount(payload);
+    $("#cloudPassword").value = "";
+    await refreshDashboard(false);
+    setStatus(result.message || "账号注册成功。", "success");
+  } catch (error) {
+    setStatus(`注册失败：${error.message}`, "error");
+  }
+}
+
+async function handleCloudLogin() {
+  try {
+    setStatus("正在登录同步账号 ...", "info");
+    const payload = getCloudFormPayload();
+    const result = await bridge.loginCloudAccount(payload);
+    $("#cloudPassword").value = "";
+    await refreshDashboard(false);
+    setStatus(result.message || "账号登录成功。", "success");
+  } catch (error) {
+    setStatus(`登录失败：${error.message}`, "error");
+  }
+}
+
+async function handleCloudLogout() {
+  try {
+    setStatus("正在退出同步账号 ...", "info");
+    const result = await bridge.logoutCloudAccount();
+    await refreshDashboard(false);
+    setStatus(result.message || "已退出同步账号。", "success");
+  } catch (error) {
+    setStatus(`退出失败：${error.message}`, "error");
+  }
+}
+
+async function handleCloudPush() {
+  try {
+    setStatus("正在把当前连接推送到账号空间 ...", "info");
+    const result = await bridge.pushCloudConfig();
+    await refreshDashboard(false);
+    setStatus(
+      result.message || `已推送 ${result.endpointCount || 0} 条连接到账号空间。`,
+      "success",
+    );
+  } catch (error) {
+    setStatus(`推送失败：${error.message}`, "error");
+  }
+}
+
+async function handleCloudPull(mode) {
+  if (mode === "replace") {
+    const confirmed = window.confirm(
+      "覆盖拉取会直接替换本机保存的连接列表。拉取前会自动备份，确定继续吗？",
+    );
+    if (!confirmed) {
+      return;
+    }
+  }
+
+  try {
+    setStatus(mode === "merge" ? "正在从账号空间合并拉取 ..." : "正在从账号空间覆盖拉取 ...", "info");
+    const result = await bridge.pullCloudConfig({ mode });
+    await refreshDashboard(false);
+    const activeHint = result.activeEndpointNote
+      ? `当前生效连接记录：${result.activeEndpointNote}。`
+      : "当前没有匹配到生效连接记录。";
+    setStatus(
+      `${result.message || "拉取完成。"} 新增 ${result.addedCount} 条，更新 ${result.updatedCount} 条。${activeHint}`,
+      "success",
+    );
+  } catch (error) {
+    setStatus(`拉取失败：${error.message}`, "error");
+  }
+}
+
 async function handleSubmitEndpoint(event) {
   event.preventDefault();
   const id = $("#endpointId").value.trim();
@@ -358,6 +534,16 @@ function bindEvents() {
     setStatus("已清空表单。", "info");
   });
   $("#enableProxyModeButton").addEventListener("click", handleEnableProxyMode);
+  $("#cloudRegisterButton").addEventListener("click", handleCloudRegister);
+  $("#cloudLoginButton").addEventListener("click", handleCloudLogin);
+  $("#cloudLogoutButton").addEventListener("click", handleCloudLogout);
+  $("#cloudPushButton").addEventListener("click", handleCloudPush);
+  $("#cloudPullMergeButton").addEventListener("click", () => {
+    handleCloudPull("merge");
+  });
+  $("#cloudPullReplaceButton").addEventListener("click", () => {
+    handleCloudPull("replace");
+  });
   $("#openCodexRootButton").addEventListener("click", () => {
     if (state.paths?.codexRoot) {
       handleOpenPath(state.paths.codexRoot, " Codex 目录");

package/src/renderer/styles.css

@@ -33,7 +33,8 @@ body {
 }
 
 button,
-input {
+input,
+textarea {
   font: inherit;
 }
 
@@ -259,7 +260,8 @@ code {
 
 input[type="text"],
 input[type="password"],
-input[type="file"] {
+input[type="file"],
+textarea {
   width: 100%;
   min-height: 46px;
   padding: 10px 14px;
@@ -269,6 +271,12 @@ input[type="file"] {
   color: var(--text);
 }
 
+textarea {
+  min-height: 168px;
+  resize: vertical;
+  line-height: 1.6;
+}
+
 input[readonly] {
   color: var(--muted);
   background: rgba(249, 244, 238, 0.95);
@@ -300,6 +308,29 @@ input[readonly] {
   gap: 10px;
 }
 
+.sync-status-grid {
+  display: grid;
+  grid-template-columns: repeat(2, minmax(0, 1fr));
+  gap: 10px;
+}
+
+.sync-status-card {
+  padding: 14px;
+  border-radius: 14px;
+  background: rgba(255, 255, 255, 0.72);
+  border: 1px solid rgba(47, 36, 30, 0.08);
+}
+
+.sync-status-card strong {
+  display: block;
+  margin-top: 8px;
+  word-break: break-all;
+}
+
+.sync-status-card-wide {
+  grid-column: span 2;
+}
+
 .metric-actions {
   margin-top: 12px;
 }
@@ -508,4 +539,12 @@ input[readonly] {
   .hero-side {
     min-height: 180px;
   }
+
+  .sync-status-grid {
+    grid-template-columns: 1fr;
+  }
+
+  .sync-status-card-wide {
+    grid-column: auto;
+  }
 }