ai-zero-token 1.0.9 → 2.0.0

package/dist/core/services/network-detect-service.js

@@ -0,0 +1,239 @@
+#!/usr/bin/env node
+import { execFile } from "node:child_process";
+import { promisify } from "node:util";
+import { requestText } from "../providers/http-client.js";
+const execFileAsync = promisify(execFile);
+const PLATFORM_PROBE_HEADERS = {
+  "accept": "text/html,application/xhtml+xml,application/xml;q=0.9,*/*;q=0.8",
+  "accept-language": "zh-CN,zh;q=0.9,en;q=0.8",
+  "cache-control": "no-cache",
+  "pragma": "no-cache",
+  "user-agent": "Mozilla/5.0 (Macintosh; Intel Mac OS X 10_15_7) AppleWebKit/537.36 (KHTML, like Gecko) Chrome/125.0.0.0 Safari/537.36"
+};
+function parseKeyValueText(input) {
+  return Object.fromEntries(
+    input.split(/\r?\n/).map((line) => line.trim()).filter(Boolean).map((line) => {
+      const index = line.indexOf("=");
+      if (index <= 0) {
+        return ["", ""];
+      }
+      return [line.slice(0, index), line.slice(index + 1)];
+    }).filter(([key]) => key)
+  );
+}
+function parseDnsServers(text) {
+  const servers = /* @__PURE__ */ new Set();
+  for (const match of text.matchAll(/nameserver\[\d+\]\s*:\s*([0-9a-fA-F:.]+)/g)) {
+    servers.add(match[1]);
+  }
+  return [...servers];
+}
+function isPrivateOrReservedIp(ip) {
+  return /^(10|127|169\.254|172\.(1[6-9]|2\d|3[0-1])|192\.168)\./.test(ip) || /^0\./.test(ip) || /^100\.(6[4-9]|[7-9]\d|1\d\d|2[0-3]\d|24[0-7])\./.test(ip) || /^198\.(18|19)\./.test(ip) || /^203\.0\.113\./.test(ip) || /^192\.0\.2\./.test(ip) || /^198\.51\.100\./.test(ip) || /^fc00:/i.test(ip) || /^fd00:/i.test(ip) || /^fe80:/i.test(ip) || /^::1$/.test(ip);
+}
+function toCountryName(code) {
+  if (!code) {
+    return void 0;
+  }
+  try {
+    return new Intl.DisplayNames(["zh-CN"], { type: "region" }).of(code) ?? code;
+  } catch {
+    return code;
+  }
+}
+async function runCommand(command, args, timeoutMs = 2500) {
+  const result = await execFileAsync(command, args, {
+    timeout: timeoutMs,
+    maxBuffer: 1024 * 128
+  });
+  return String(result.stdout || "");
+}
+async function readDnsServers() {
+  const servers = /* @__PURE__ */ new Set();
+  let source = "\u7CFB\u7EDF DNS";
+  try {
+    const scutil = await runCommand("scutil", ["--dns"], 2500);
+    parseDnsServers(scutil).forEach((item) => servers.add(item));
+    source = "scutil --dns";
+  } catch {
+  }
+  try {
+    const wifiDns = await runCommand("networksetup", ["-getdnsservers", "Wi-Fi"], 2500);
+    for (const line of wifiDns.split(/\r?\n/)) {
+      const value = line.trim();
+      if (value && /^[0-9a-fA-F:.]+$/.test(value)) {
+        servers.add(value);
+      }
+    }
+    if (servers.size > 0) {
+      source = `${source} + networksetup`;
+    }
+  } catch {
+  }
+  return {
+    servers: [...servers],
+    source
+  };
+}
+async function probePublicIpv4(proxy) {
+  const startedAt = performance.now();
+  const response = await requestText({
+    method: "GET",
+    url: "https://ifconfig.me/ip",
+    timeoutMs: 8e3,
+    proxyOverride: proxy
+  });
+  if (response.status < 200 || response.status >= 500) {
+    throw new Error(`\u516C\u7F51 IPv4 \u63A2\u6D4B\u5931\u8D25: HTTP ${response.status}`);
+  }
+  const ip = response.body.trim();
+  let trace = {};
+  try {
+    const traceResponse = await requestText({
+      method: "GET",
+      url: "https://www.cloudflare.com/cdn-cgi/trace",
+      timeoutMs: 8e3,
+      proxyOverride: proxy
+    });
+    trace = parseKeyValueText(traceResponse.body);
+  } catch {
+    trace = {};
+  }
+  const countryCode = trace.loc;
+  return {
+    ip,
+    countryCode,
+    countryName: toCountryName(countryCode),
+    colo: trace.colo,
+    source: "ifconfig.me + cloudflare trace",
+    elapsedMs: Math.round(performance.now() - startedAt)
+  };
+}
+async function probePublicIpv6(proxy) {
+  const startedAt = performance.now();
+  const ipv6Candidates = [
+    "https://ifconfig.me/ipv6",
+    "https://ipv6.test-ipv6.com/"
+  ];
+  for (const url of ipv6Candidates) {
+    try {
+      const response = await requestText({
+        method: "GET",
+        url,
+        timeoutMs: 6e3,
+        proxyOverride: proxy
+      });
+      const body = response.body.trim();
+      if (!body) {
+        continue;
+      }
+      if (/^[0-9a-fA-F:]+$/.test(body) && body.includes(":")) {
+        return {
+          available: true,
+          ip: body,
+          source: url,
+          detail: "\u68C0\u6D4B\u5230\u72EC\u7ACB IPv6 \u51FA\u53E3\u3002",
+          elapsedMs: Math.round(performance.now() - startedAt)
+        };
+      }
+    } catch {
+    }
+  }
+  return {
+    available: false,
+    source: "ifconfig.me / test-ipv6.com",
+    detail: "\u672A\u68C0\u6D4B\u5230\u72EC\u7ACB IPv6 \u51FA\u53E3\uFF0C\u5F53\u524D\u8FDE\u63A5\u53EF\u80FD\u53EA\u8D70 IPv4\u3002"
+  };
+}
+async function probePlatform(url, label, proxy) {
+  const startedAt = performance.now();
+  try {
+    const response = await requestText({
+      method: "GET",
+      url,
+      headers: PLATFORM_PROBE_HEADERS,
+      timeoutMs: 8e3,
+      proxyOverride: proxy
+    });
+    const elapsedMs = Math.round(performance.now() - startedAt);
+    if (response.status >= 200 && response.status < 400) {
+      return {
+        key: label,
+        label,
+        url,
+        status: "\u53EF\u8FBE",
+        detail: `HTTP ${response.status} \u53EF\u6B63\u5E38\u8BBF\u95EE`,
+        tone: "green",
+        httpStatus: response.status,
+        elapsedMs
+      };
+    }
+    if (response.status >= 400 && response.status < 500) {
+      return {
+        key: label,
+        label,
+        url,
+        status: "\u53D7\u9650",
+        detail: `HTTP ${response.status}\uFF0C\u7F51\u7EDC\u53EF\u8FBE\u4F46\u7AD9\u70B9\u8FD4\u56DE\u9650\u5236`,
+        tone: "orange",
+        httpStatus: response.status,
+        elapsedMs
+      };
+    }
+    return {
+      key: label,
+      label,
+      url,
+      status: "\u4E0D\u53EF\u7528",
+      detail: `HTTP ${response.status}\uFF0C\u7AD9\u70B9\u4E0D\u53EF\u7528`,
+      tone: "red",
+      httpStatus: response.status,
+      elapsedMs
+    };
+  } catch (error) {
+    return {
+      key: label,
+      label,
+      url,
+      status: "\u4E0D\u53EF\u7528",
+      detail: error instanceof Error ? error.message : String(error),
+      tone: "red",
+      elapsedMs: Math.round(performance.now() - startedAt)
+    };
+  }
+}
+class NetworkDetectService {
+  async collectReport(proxy) {
+    const [publicIpv4, publicIpv6, dns, platforms] = await Promise.all([
+      probePublicIpv4(proxy),
+      probePublicIpv6(proxy),
+      readDnsServers(),
+      Promise.all([
+        probePlatform("https://www.google.com/generate_204", "Google", proxy),
+        probePlatform("https://chatgpt.com/", "ChatGPT", proxy),
+        probePlatform("https://claude.ai/", "Claude", proxy),
+        probePlatform("https://www.youtube.com/", "YouTube", proxy),
+        probePlatform("https://x.com/", "X", proxy)
+      ])
+    ]);
+    const dnsDetail = dns.servers.length > 0 ? `\u7CFB\u7EDF DNS: ${dns.servers.join(" / ")}` : "\u672A\u8BFB\u53D6\u5230\u7CFB\u7EDF DNS\u3002";
+    return {
+      checkedAt: Date.now(),
+      publicIpv4,
+      publicIpv6,
+      dns: {
+        servers: dns.servers,
+        source: dns.source,
+        detail: dnsDetail
+      },
+      proxy: {
+        enabled: Boolean(proxy?.enabled && proxy.url.trim()),
+        url: proxy?.url?.trim() || void 0
+      },
+      platforms
+    };
+  }
+}
+export {
+  NetworkDetectService
+};

package/dist/desktop/main.js

@@ -0,0 +1,143 @@
+#!/usr/bin/env node
+import { app as electronApp, BrowserWindow, dialog, shell } from "electron";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { startServer } from "../server/index.js";
+let gatewayServer = null;
+let mainWindow = null;
+let isQuitting = false;
+const desktopDir = path.dirname(fileURLToPath(import.meta.url));
+const appIconPath = path.resolve(desktopDir, "../../build/icon.png");
+electronApp.setName("AI Zero Token");
+function createBrowserUrl(host, port) {
+  if (host === "0.0.0.0" || host === "::") {
+    return `http://127.0.0.1:${port}`;
+  }
+  return `http://${host}:${port}`;
+}
+function isGatewayUrl(targetUrl, gatewayUrl) {
+  try {
+    const target = new URL(targetUrl);
+    const gateway = new URL(gatewayUrl);
+    return target.origin === gateway.origin;
+  } catch {
+    return false;
+  }
+}
+function resolveAdminUrl(gatewayUrl) {
+  const devUrl = process.env.AZT_ADMIN_UI_DEV_URL?.trim();
+  return devUrl || gatewayUrl;
+}
+async function ensureGatewayServer() {
+  if (gatewayServer) {
+    return gatewayServer;
+  }
+  gatewayServer = await startServer();
+  const adminUrl = createBrowserUrl(gatewayServer.host, gatewayServer.port);
+  console.log("AI Zero Token desktop gateway started.");
+  console.log(`admin: ${adminUrl}`);
+  console.log(`apiBase: ${adminUrl}/v1`);
+  console.log(`listen: http://${gatewayServer.host}:${gatewayServer.port}`);
+  return gatewayServer;
+}
+async function createMainWindow() {
+  const server = await ensureGatewayServer();
+  const gatewayUrl = createBrowserUrl(server.host, server.port);
+  const adminUrl = resolveAdminUrl(gatewayUrl);
+  mainWindow = new BrowserWindow({
+    width: 1440,
+    height: 960,
+    minWidth: 1100,
+    minHeight: 720,
+    title: "AI Zero Token",
+    icon: appIconPath,
+    backgroundColor: "#f8fafc",
+    webPreferences: {
+      contextIsolation: true,
+      nodeIntegration: false,
+      sandbox: true
+    }
+  });
+  mainWindow.webContents.setWindowOpenHandler(({ url }) => {
+    void shell.openExternal(url);
+    return { action: "deny" };
+  });
+  mainWindow.webContents.on("will-navigate", (event, url) => {
+    if (isGatewayUrl(url, adminUrl) || isGatewayUrl(url, gatewayUrl)) {
+      return;
+    }
+    event.preventDefault();
+    void shell.openExternal(url);
+  });
+  mainWindow.on("closed", () => {
+    mainWindow = null;
+  });
+  await mainWindow.loadURL(adminUrl);
+}
+function focusMainWindow() {
+  if (!mainWindow) {
+    void createMainWindow().catch(handleStartupError);
+    return;
+  }
+  if (mainWindow.isMinimized()) {
+    mainWindow.restore();
+  }
+  mainWindow.focus();
+}
+async function closeGatewayServer() {
+  if (!gatewayServer) {
+    return;
+  }
+  const server = gatewayServer;
+  gatewayServer = null;
+  await server.app.close();
+}
+function handleStartupError(error) {
+  const message = error instanceof Error ? error.message : String(error);
+  console.error("[desktop:error]", error);
+  if (electronApp.isReady()) {
+    dialog.showErrorBox("AI Zero Token \u542F\u52A8\u5931\u8D25", message);
+  }
+  electronApp.quit();
+}
+const hasSingleInstanceLock = electronApp.requestSingleInstanceLock();
+if (!hasSingleInstanceLock) {
+  electronApp.quit();
+} else {
+  electronApp.on("second-instance", () => {
+    focusMainWindow();
+  });
+  electronApp.whenReady().then(() => {
+    if (process.platform === "darwin") {
+      electronApp.dock?.setIcon(appIconPath);
+    }
+    electronApp.setAboutPanelOptions({
+      applicationName: "AI Zero Token",
+      applicationVersion: electronApp.getVersion(),
+      iconPath: appIconPath
+    });
+    return createMainWindow();
+  }).catch(handleStartupError);
+  electronApp.on("activate", () => {
+    if (BrowserWindow.getAllWindows().length === 0) {
+      focusMainWindow();
+    }
+  });
+  electronApp.on("window-all-closed", () => {
+    if (process.platform !== "darwin") {
+      electronApp.quit();
+    }
+  });
+  electronApp.on("before-quit", (event) => {
+    if (!gatewayServer || isQuitting) {
+      return;
+    }
+    event.preventDefault();
+    isQuitting = true;
+    void closeGatewayServer().catch((error) => {
+      console.error("[desktop:gateway:close]", error);
+    }).finally(() => {
+      electronApp.quit();
+    });
+  });
+}

package/dist/server/admin-page.js

@@ -1898,6 +1898,7 @@ function renderAdminPage() {
                 <option value="all">\u5168\u90E8\u72B6\u6001</option>
                 <option value="healthy">\u5065\u5EB7</option>
                 <option value="warning">\u5373\u5C06\u8017\u5C3D</option>
+                <option value="invalid">\u767B\u5F55\u5931\u6548</option>
                 <option value="expired">\u5DF2\u8FC7\u671F</option>
                 <option value="active">\u4F7F\u7528\u4E2D</option>
               </select>
@@ -2302,6 +2303,13 @@ function renderAdminPage() {
       return date.toLocaleString("zh-CN", { hour12: false });
     }
 
+    function timestampToMillis(value) {
+      if (typeof value !== "number" || !Number.isFinite(value) || value <= 0) {
+        return null;
+      }
+      return value < 1000000000000 ? value * 1000 : value;
+    }
+
     function formatShortTime(value) {
       if (!value) {
         return "--:--";
@@ -2528,6 +2536,15 @@ function renderAdminPage() {
         };
       }
 
+      if (profile.authStatus && (profile.authStatus.state === "token_invalidated" || profile.authStatus.state === "auth_error")) {
+        return {
+          supported: false,
+          label: "\u8BA4\u8BC1\u5931\u6548",
+          detail: "\u8D26\u53F7\u8BA4\u8BC1\u5DF2\u5931\u6548\uFF0C\u8BF7\u91CD\u65B0\u767B\u5F55\u540E\u518D\u4F7F\u7528\u56FE\u7247\u751F\u6210\u3002",
+          badgeClass: "red",
+        };
+      }
+
       const planType = getPlanType(profile);
       if (planType === "free") {
         return {
@@ -2546,6 +2563,17 @@ function renderAdminPage() {
       };
     }
 
+    function describeAuthStatus(profile) {
+      const authStatus = profile && profile.authStatus ? profile.authStatus : null;
+      if (!authStatus || authStatus.state === "ok") {
+        return authStatus && authStatus.checkedAt ? "\u6B63\u5E38 \xB7 " + formatTime(authStatus.checkedAt) : "\u6B63\u5E38";
+      }
+
+      const prefix = authStatus.state === "token_invalidated" ? "\u767B\u5F55\u5931\u6548" : "\u8BA4\u8BC1\u5F02\u5E38";
+      const detail = authStatus.code || authStatus.httpStatus ? " (" + (authStatus.code || authStatus.httpStatus) + ")" : "";
+      return prefix + detail + " \xB7 " + formatTime(authStatus.checkedAt);
+    }
+
     function maskEmail(email) {
       if (typeof email !== "string" || email.indexOf("@") === -1) {
         return email || "";
@@ -2620,6 +2648,10 @@ function renderAdminPage() {
       return Math.max(0, Math.min(100, value));
     }
 
+    function getPrimaryRemaining(profile) {
+      return 100 - getPrimaryUsage(profile);
+    }
+
     function getSecondaryUsage(profile) {
       const value = profile && profile.quota && typeof profile.quota.secondaryUsedPercent === "number"
         ? profile.quota.secondaryUsedPercent
@@ -2664,6 +2696,22 @@ function renderAdminPage() {
 
     function getProfileHealth(profile) {
       const now = Date.now();
+      if (profile && profile.authStatus && profile.authStatus.state === "token_invalidated") {
+        return {
+          key: "invalid",
+          label: "\u767B\u5F55\u5931\u6548",
+          badgeClass: "red",
+          barClass: "red",
+        };
+      }
+      if (profile && profile.authStatus && profile.authStatus.state === "auth_error") {
+        return {
+          key: "invalid",
+          label: "\u8BA4\u8BC1\u5F02\u5E38",
+          badgeClass: "red",
+          barClass: "red",
+        };
+      }
       if (profile && profile.expiresAt && profile.expiresAt <= now) {
         return {
           key: "expired",
@@ -2700,6 +2748,22 @@ function renderAdminPage() {
       };
     }
 
+    function isProfileUnavailable(profile) {
+      const health = getProfileHealth(profile);
+      return health.key === "invalid" || health.key === "expired";
+    }
+
+    function getProfileSortGroup(profile, codexAccountId) {
+      const isCodexActive = Boolean(codexAccountId && profile.accountId === codexAccountId);
+      if (profile.isActive || isCodexActive) {
+        return 0;
+      }
+      if (isProfileUnavailable(profile)) {
+        return 2;
+      }
+      return 1;
+    }
+
     function describeReset(profile, slot) {
       if (!profile || !profile.quota) {
         return "\u6682\u65E0\u6570\u636E";
@@ -2708,8 +2772,9 @@ function renderAdminPage() {
       const quota = profile.quota;
       const resetAt = slot === "primary" ? quota.primaryResetAt : quota.secondaryResetAt;
       const resetAfter = slot === "primary" ? quota.primaryResetAfterSeconds : quota.secondaryResetAfterSeconds;
-      if (typeof resetAt === "number" && resetAt > 0) {
-        return formatTime(resetAt * 1000);
+      const resetAtMillis = timestampToMillis(resetAt);
+      if (resetAtMillis) {
+        return formatTime(resetAtMillis);
       }
       if (typeof resetAfter === "number" && resetAfter > 0) {
         return formatCompactDuration(resetAfter) + "\u540E";
@@ -2739,11 +2804,13 @@ function renderAdminPage() {
       const quota = profile.quota;
       const resetAt = slot === "primary" ? quota.primaryResetAt : quota.secondaryResetAt;
       const resetAfter = slot === "primary" ? quota.primaryResetAfterSeconds : quota.secondaryResetAfterSeconds;
-      if (typeof resetAt === "number" && resetAt > 0) {
-        return formatCompactDateTime(resetAt * 1000);
+      const resetAtMillis = timestampToMillis(resetAt);
+      if (resetAtMillis) {
+        return formatCompactDateTime(resetAtMillis);
       }
       if (typeof resetAfter === "number" && resetAfter > 0) {
-        return formatCompactDuration(resetAfter) + "\u540E";
+        const capturedAt = timestampToMillis(quota.capturedAt);
+        return capturedAt ? formatCompactDateTime(capturedAt + resetAfter * 1000) : formatCompactDuration(resetAfter) + "\u540E";
       }
       return "\u672A\u77E5";
     }
@@ -3169,6 +3236,9 @@ function renderAdminPage() {
         if (status === "warning" && health.key !== "warning") {
           return false;
         }
+        if (status === "invalid" && health.key !== "invalid") {
+          return false;
+        }
         if (status === "expired" && health.key !== "expired") {
           return false;
         }
@@ -3176,24 +3246,18 @@ function renderAdminPage() {
       });
 
       filtered.sort(function (a, b) {
-        const aCodexActive = Boolean(codexAccountId && a.accountId === codexAccountId);
-        const bCodexActive = Boolean(codexAccountId && b.accountId === codexAccountId);
-        const activeDiff = Number(b.isActive || bCodexActive) - Number(a.isActive || aCodexActive);
-        if (activeDiff !== 0) {
-          return activeDiff;
-        }
-        const gatewayDiff = Number(b.isActive) - Number(a.isActive);
-        if (gatewayDiff !== 0) {
-          return gatewayDiff;
-        }
-        const codexDiff = Number(bCodexActive) - Number(aCodexActive);
-        if (codexDiff !== 0) {
-          return codexDiff;
+        const groupDiff = getProfileSortGroup(a, codexAccountId) - getProfileSortGroup(b, codexAccountId);
+        if (groupDiff !== 0) {
+          return groupDiff;
         }
         const planDiff = getPlanRank(b) - getPlanRank(a);
         if (planDiff !== 0) {
           return planDiff;
         }
+        const primaryRemainingDiff = getPrimaryRemaining(b) - getPrimaryRemaining(a);
+        if (primaryRemainingDiff !== 0) {
+          return primaryRemainingDiff;
+        }
         if (sort === "latency-asc") {
           const aCapturedAt = getQuotaSnapshotTime(a) || 0;
           const bCapturedAt = getQuotaSnapshotTime(b) || 0;
@@ -3344,6 +3408,7 @@ function renderAdminPage() {
             ? '<div class="meta-grid">'
               + '<div class="meta-item"><label>\u5957\u9910</label><strong>' + escapeHtml(planType) + "</strong></div>"
               + '<div class="meta-item"><label>\u751F\u56FE\u80FD\u529B</label><strong>' + escapeHtml(imageCapability.detail) + "</strong></div>"
+              + '<div class="meta-item"><label>\u8BA4\u8BC1\u72B6\u6001</label><strong>' + escapeHtml(describeAuthStatus(profile)) + "</strong></div>"
               + '<div class="meta-item"><label>\u989D\u5EA6\u5FEB\u7167</label><strong>' + escapeHtml(describeQuotaSnapshot(profile)) + "</strong></div>"
               + '<div class="meta-item"><label>\u989D\u5EA6\u9650\u5236</label><strong>' + escapeHtml(describeQuotaLimit(profile)) + "</strong></div>"
               + '<div class="meta-item"><label>Account ID</label><code>' + escapeHtml(state.showEmails ? (profile.accountId || "\u672A\u63D0\u4F9B") : maskIdentifier(profile.accountId || "\u672A\u63D0\u4F9B")) + "</code></div>"
@@ -3353,6 +3418,7 @@ function renderAdminPage() {
           +   '<div class="account-actions">'
           +     actionButton
           +     codexButton
+          +     '<button class="btn-secondary" type="button" data-profile-action="sync-quota" data-profile-id="' + escapeHtml(profile.profileId) + '">\u5237\u65B0\u989D\u5EA6</button>'
           +     '<button class="btn-secondary" type="button" data-profile-action="export" data-profile-id="' + escapeHtml(profile.profileId) + '">\u5BFC\u51FA</button>'
           +     '<button class="btn-danger" type="button" data-profile-action="remove" data-profile-id="' + escapeHtml(profile.profileId) + '">\u5220\u9664</button>'
           +   "</div>"
@@ -3862,6 +3928,28 @@ function renderAdminPage() {
         await applyProfileToCodex(profileId, button);
         return;
       }
+      if (action === "sync-quota") {
+        setBusy(button, true);
+        authStatus.textContent = "\u6B63\u5728\u5237\u65B0\u8D26\u53F7\u989D\u5EA6...";
+        try {
+          const config = await fetchJson("/_gateway/admin/profiles/sync-quota", {
+            method: "POST",
+            headers: {
+              "Content-Type": "application/json",
+            },
+            body: formatJson({
+              profileId: profileId,
+            }),
+          });
+          renderConfig(config);
+          authStatus.textContent = "\u989D\u5EA6\u4FE1\u606F\u5DF2\u540C\u6B65\u3002";
+        } catch (error) {
+          authStatus.textContent = error.message;
+        } finally {
+          setBusy(button, false);
+        }
+        return;
+      }
 
       setBusy(button, true);
       authStatus.textContent = action === "activate" ? "\u6B63\u5728\u5207\u6362\u5F53\u524D\u8D26\u53F7..." : "\u6B63\u5728\u5220\u9664\u8D26\u53F7...";
@@ -4285,7 +4373,12 @@ function renderAdminPage() {
       authStatus.textContent = "\u6B63\u5728\u540C\u6B65\u989D\u5EA6\u4E0E\u7248\u672C\u72B6\u6001...";
       refreshConfig({
         syncRuntime: true,
-      }).then(function () {
+      }).then(function (config) {
+        if (config && config.quotaSync) {
+          const sync = config.quotaSync;
+          authStatus.textContent = "\u989D\u5EA6\u4E0E\u7248\u672C\u72B6\u6001\u5DF2\u5237\u65B0: " + String(sync.synced) + "/" + String(sync.total) + " \u4E2A\u8D26\u53F7\u6210\u529F" + (sync.failed ? "\uFF0C" + String(sync.failed) + " \u4E2A\u5931\u8D25" : "") + (sync.skipped ? "\uFF0C" + String(sync.skipped) + " \u4E2A\u767B\u5F55\u5931\u6548\u5DF2\u8DF3\u8FC7" : "") + "\u3002";
+          return;
+        }
         authStatus.textContent = "\u989D\u5EA6\u4E0E\u7248\u672C\u72B6\u6001\u5DF2\u5237\u65B0\u3002";
       }).catch(function (error) {
         authStatus.textContent = error && error.message ? error.message : String(error);