feat: GitHub Star badge + check-for-updates in dashboard header

- Header: ⭐ Star badge linking to GitHub repo (amber pill style)
- Header: 🔄 Check for Updates button with status display
- Checks both proxy self-update (git fetch/pull/build) and Codex fingerprint (appcast)
- CLI: auto git pull + npm install + build, prompt restart
- Docker: fingerprint auto-update, proxy shows manual rebuild hint
- Electron: version display only, managed by desktop app
- New endpoints: GET /admin/update-status, POST /admin/check-update
- Footer: version info (proxy commit + Codex Desktop version)

Co-Authored-By: Claude Opus 4.6 <noreply@anthropic.com>

CHANGELOG.md

@@ -8,6 +8,15 @@
 
 ### Added
 
+- Dashboard GitHub Star 徽章：Header 新增醒目的 ⭐ Star 按钮（amber 药丸样式），点击跳转 GitHub 仓库页面，方便用户收藏和获取更新
+- Dashboard 检查更新功能：Footer 显示 Proxy 版本+commit 和 Codex Desktop 指纹版本，提供"检查更新"按钮同时检查两种更新
+  - Proxy 自更新（CLI 模式）：通过 `git fetch` 检查新提交，自动执行 `git pull + npm install + npm run build`，完成后提示重启
+  - Codex 指纹更新：手动触发现有 appcast 检查，自动应用指纹/模型配置变更
+  - Docker 兼容：指纹可自动更新，代理代码提示手动 `docker compose up -d --build`
+  - Electron 兼容：显示版本信息，更新由桌面应用管理
+- `GET /admin/update-status` 端点：返回 proxy 和 codex 两种更新的当前状态
+- `POST /admin/check-update` 端点：同时触发 proxy 自检 + codex 指纹检查，自动应用可用更新
+- `src/self-update.ts`：Proxy 自更新模块（git 子进程实现，支持检查/拉取/构建）
 - GPT-5.4 + Codex Spark 模型支持：新增 `gpt-5.4`（4 种 effort: minimal/low/medium/high）和 `gpt-5.3-codex-spark`（minimal/low），`codex` 别名更新为 `gpt-5.4`
 - 扩展推理等级：支持 `minimal`、`xhigh` 等新 effort 值，客户端发送的任意 `reasoning_effort` 均透传到后端
 - 模型家族矩阵选择器：Dashboard 模型选择从平面下拉改为家族列表 + 推理等级按钮组，通过 `/v1/models/catalog` 端点获取完整目录

shared/hooks/use-update-status.ts

@@ -0,0 +1,79 @@
+import { useState, useEffect, useCallback } from "preact/hooks";
+
+export interface UpdateStatus {
+  proxy: {
+    version: string;
+    commit: string | null;
+    can_self_update: boolean;
+    commits_behind: number | null;
+    update_in_progress: boolean;
+  };
+  codex: {
+    current_version: string | null;
+    current_build: string | null;
+    latest_version: string | null;
+    latest_build: string | null;
+    update_available: boolean;
+    update_in_progress: boolean;
+    last_check: string | null;
+  };
+}
+
+export interface CheckResult {
+  proxy?: {
+    commits_behind: number;
+    current_commit: string | null;
+    latest_commit: string | null;
+    update_applied?: boolean;
+    error?: string;
+  };
+  codex?: {
+    update_available: boolean;
+    current_version: string;
+    latest_version: string | null;
+    error?: string;
+  };
+  proxy_update_in_progress: boolean;
+  codex_update_in_progress: boolean;
+}
+
+export function useUpdateStatus() {
+  const [status, setStatus] = useState<UpdateStatus | null>(null);
+  const [checking, setChecking] = useState(false);
+  const [result, setResult] = useState<CheckResult | null>(null);
+  const [error, setError] = useState<string | null>(null);
+
+  const load = useCallback(async () => {
+    try {
+      const resp = await fetch("/admin/update-status");
+      if (resp.ok) {
+        setStatus(await resp.json());
+      }
+    } catch { /* ignore */ }
+  }, []);
+
+  useEffect(() => { load(); }, [load]);
+
+  const checkForUpdate = useCallback(async () => {
+    setChecking(true);
+    setError(null);
+    setResult(null);
+    try {
+      const resp = await fetch("/admin/check-update", { method: "POST" });
+      const data: CheckResult = await resp.json();
+      if (!resp.ok) {
+        setError("Check failed");
+      } else {
+        setResult(data);
+        // Refresh status after check
+        await load();
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Network error");
+    } finally {
+      setChecking(false);
+    }
+  }, [load]);
+
+  return { status, checking, result, error, checkForUpdate };
+}

shared/i18n/translations.ts

@@ -59,6 +59,19 @@ export const translations = {
     refresh: "Refresh",
     updatedAt: "Updated at",
     footer: "\u00a9 2025 Codex Proxy. All rights reserved.",
+    starOnGithub: "Star",
+    checkForUpdates: "Check for Updates",
+    checkingUpdates: "Checking...",
+    upToDate: "Up to date",
+    updateApplied: "Update complete, please restart server",
+    fingerprintUpdated: "Fingerprint updated",
+    proxyUpdating: "Updating proxy...",
+    proxyBehind: "behind",
+    dockerUpdateHint: "Run: docker compose up -d --build",
+    managedByDesktop: "Managed by desktop app",
+    lastChecked: "Last checked",
+    never: "never",
+    commits: "commits",
   },
   zh: {
     serverOnline: "\u670d\u52a1\u8fd0\u884c\u4e2d",
@@ -123,6 +136,19 @@ export const translations = {
     updatedAt: "\u66f4\u65b0\u4e8e",
     footer:
       "\u00a9 2025 Codex Proxy\u3002\u4fdd\u7559\u6240\u6709\u6743\u5229\u3002",
+    starOnGithub: "\u6536\u85cf",
+    checkForUpdates: "\u68c0\u67e5\u66f4\u65b0",
+    checkingUpdates: "\u68c0\u67e5\u4e2d...",
+    upToDate: "\u5df2\u662f\u6700\u65b0",
+    updateApplied: "\u66f4\u65b0\u5b8c\u6210\uff0c\u8bf7\u91cd\u542f\u670d\u52a1",
+    fingerprintUpdated: "\u6307\u7eb9\u5df2\u66f4\u65b0",
+    proxyUpdating: "\u6b63\u5728\u66f4\u65b0\u4ee3\u7406...",
+    proxyBehind: "\u843d\u540e",
+    dockerUpdateHint: "\u8bf7\u6267\u884c: docker compose up -d --build",
+    managedByDesktop: "\u7531\u684c\u9762\u5e94\u7528\u7ba1\u7406",
+    lastChecked: "\u4e0a\u6b21\u68c0\u67e5",
+    never: "\u4ece\u672a",
+    commits: "\u4e2a\u63d0\u4ea4",
   },
 } as const;
 

src/routes/web.ts

@@ -4,7 +4,9 @@ import { readFileSync, existsSync } from "fs";
 import { resolve } from "path";
 import type { AccountPool } from "../auth/account-pool.js";
 import { getConfig, getFingerprint } from "../config.js";
-import { getPublicDir, getDesktopPublicDir, getConfigDir, getDataDir } from "../paths.js";
+import { getPublicDir, getDesktopPublicDir, getConfigDir, getDataDir, isEmbedded } from "../paths.js";
+import { getUpdateState, checkForUpdate, isUpdateInProgress } from "../update-checker.js";
+import { getProxyInfo, canSelfUpdate, checkProxySelfUpdate, applyProxySelfUpdate, isProxyUpdateInProgress } from "../self-update.js";
 
 export function createWebRoutes(accountPool: AccountPool): Hono {
   const app = new Hono();
@@ -120,5 +122,89 @@ export function createWebRoutes(accountPool: AccountPool): Hono {
     });
   });
 
+  // --- Update management endpoints ---
+
+  app.get("/admin/update-status", (c) => {
+    const proxyInfo = getProxyInfo();
+    const codexState = getUpdateState();
+
+    return c.json({
+      proxy: {
+        version: proxyInfo.version,
+        commit: proxyInfo.commit,
+        can_self_update: canSelfUpdate(),
+        commits_behind: null as number | null,
+        update_in_progress: isProxyUpdateInProgress(),
+      },
+      codex: {
+        current_version: codexState?.current_version ?? null,
+        current_build: codexState?.current_build ?? null,
+        latest_version: codexState?.latest_version ?? null,
+        latest_build: codexState?.latest_build ?? null,
+        update_available: codexState?.update_available ?? false,
+        update_in_progress: isUpdateInProgress(),
+        last_check: codexState?.last_check ?? null,
+      },
+    });
+  });
+
+  app.post("/admin/check-update", async (c) => {
+    const results: {
+      proxy?: { commits_behind: number; current_commit: string | null; latest_commit: string | null; update_applied?: boolean; error?: string };
+      codex?: { update_available: boolean; current_version: string; latest_version: string | null; error?: string };
+    } = {};
+
+    // 1. Proxy self-update check
+    if (canSelfUpdate()) {
+      try {
+        const proxyResult = await checkProxySelfUpdate();
+        results.proxy = {
+          commits_behind: proxyResult.commitsBehind,
+          current_commit: proxyResult.currentCommit,
+          latest_commit: proxyResult.latestCommit,
+        };
+
+        // Auto-apply if behind
+        if (proxyResult.commitsBehind > 0 && !isProxyUpdateInProgress()) {
+          const applyResult = await applyProxySelfUpdate();
+          results.proxy.update_applied = applyResult.started;
+          if (applyResult.error) results.proxy.error = applyResult.error;
+        }
+      } catch (err) {
+        results.proxy = {
+          commits_behind: 0,
+          current_commit: null,
+          latest_commit: null,
+          error: err instanceof Error ? err.message : String(err),
+        };
+      }
+    }
+
+    // 2. Codex fingerprint check
+    if (!isEmbedded()) {
+      try {
+        const codexState = await checkForUpdate();
+        results.codex = {
+          update_available: codexState.update_available,
+          current_version: codexState.current_version,
+          latest_version: codexState.latest_version,
+        };
+      } catch (err) {
+        results.codex = {
+          update_available: false,
+          current_version: "unknown",
+          latest_version: null,
+          error: err instanceof Error ? err.message : String(err),
+        };
+      }
+    }
+
+    return c.json({
+      ...results,
+      proxy_update_in_progress: isProxyUpdateInProgress(),
+      codex_update_in_progress: isUpdateInProgress(),
+    });
+  });
+
   return app;
 }

src/self-update.ts

@@ -0,0 +1,150 @@
+/**
+ * Proxy self-update — checks for new commits on GitHub and applies via git pull.
+ * Only works in CLI mode (where .git exists). Docker/Electron show manual instructions.
+ */
+
+import { execFile, execFileSync } from "child_process";
+import { existsSync, readFileSync } from "fs";
+import { resolve } from "path";
+import { promisify } from "util";
+import { isEmbedded } from "./paths.js";
+
+const execFileAsync = promisify(execFile);
+
+export interface ProxyInfo {
+  version: string;
+  commit: string | null;
+}
+
+export interface ProxySelfUpdateResult {
+  commitsBehind: number;
+  currentCommit: string | null;
+  latestCommit: string | null;
+}
+
+let _proxyUpdateInProgress = false;
+let _gitAvailable: boolean | null = null;
+
+/** Read proxy version from package.json + current git commit hash. */
+export function getProxyInfo(): ProxyInfo {
+  let version = "unknown";
+  try {
+    const pkg = JSON.parse(readFileSync(resolve(process.cwd(), "package.json"), "utf-8"));
+    version = pkg.version ?? "unknown";
+  } catch { /* ignore */ }
+
+  let commit: string | null = null;
+  if (canSelfUpdate()) {
+    try {
+      const out = execFileSync("git", ["rev-parse", "--short", "HEAD"], {
+        cwd: process.cwd(),
+        encoding: "utf-8",
+        timeout: 5000,
+      });
+      commit = out.trim() || null;
+    } catch { /* ignore */ }
+  }
+
+  return { version, commit };
+}
+
+/** Whether this environment supports git-based self-update. */
+export function canSelfUpdate(): boolean {
+  if (isEmbedded()) return false;
+  if (_gitAvailable !== null) return _gitAvailable;
+
+  // Check .git directory exists
+  if (!existsSync(resolve(process.cwd(), ".git"))) {
+    _gitAvailable = false;
+    return false;
+  }
+
+  // Check git command is available
+  try {
+    execFileSync("git", ["--version"], {
+      cwd: process.cwd(),
+      timeout: 5000,
+      stdio: "ignore",
+    });
+    _gitAvailable = true;
+  } catch {
+    _gitAvailable = false;
+  }
+
+  return _gitAvailable;
+}
+
+/** Whether a proxy self-update is currently in progress. */
+export function isProxyUpdateInProgress(): boolean {
+  return _proxyUpdateInProgress;
+}
+
+/** Fetch latest from origin and check how many commits behind. */
+export async function checkProxySelfUpdate(): Promise<ProxySelfUpdateResult> {
+  const cwd = process.cwd();
+
+  // Get current commit
+  let currentCommit: string | null = null;
+  try {
+    const { stdout } = await execFileAsync("git", ["rev-parse", "--short", "HEAD"], { cwd, timeout: 5000 });
+    currentCommit = stdout.trim() || null;
+  } catch { /* ignore */ }
+
+  // Fetch latest
+  try {
+    await execFileAsync("git", ["fetch", "origin", "master", "--quiet"], { cwd, timeout: 30000 });
+  } catch (err) {
+    console.warn("[SelfUpdate] git fetch failed:", err instanceof Error ? err.message : err);
+    return { commitsBehind: 0, currentCommit, latestCommit: currentCommit };
+  }
+
+  // Count commits behind
+  let commitsBehind = 0;
+  let latestCommit: string | null = null;
+  try {
+    const { stdout: countOut } = await execFileAsync(
+      "git", ["rev-list", "HEAD..origin/master", "--count"], { cwd, timeout: 5000 },
+    );
+    commitsBehind = parseInt(countOut.trim(), 10) || 0;
+
+    const { stdout: latestOut } = await execFileAsync(
+      "git", ["rev-parse", "--short", "origin/master"], { cwd, timeout: 5000 },
+    );
+    latestCommit = latestOut.trim() || null;
+  } catch { /* ignore */ }
+
+  return { commitsBehind, currentCommit, latestCommit };
+}
+
+/**
+ * Apply proxy self-update: git pull + npm install + npm run build.
+ * Runs in background. Returns immediately; check isProxyUpdateInProgress() for status.
+ */
+export async function applyProxySelfUpdate(): Promise<{ started: boolean; error?: string }> {
+  if (_proxyUpdateInProgress) {
+    return { started: false, error: "Update already in progress" };
+  }
+
+  _proxyUpdateInProgress = true;
+  const cwd = process.cwd();
+
+  try {
+    console.log("[SelfUpdate] Pulling latest code...");
+    await execFileAsync("git", ["pull", "origin", "master"], { cwd, timeout: 60000 });
+
+    console.log("[SelfUpdate] Installing dependencies...");
+    await execFileAsync("npm", ["install"], { cwd, timeout: 120000, shell: true });
+
+    console.log("[SelfUpdate] Building...");
+    await execFileAsync("npm", ["run", "build"], { cwd, timeout: 120000, shell: true });
+
+    console.log("[SelfUpdate] Update complete. Server restart required.");
+    _proxyUpdateInProgress = false;
+    return { started: true };
+  } catch (err) {
+    _proxyUpdateInProgress = false;
+    const msg = err instanceof Error ? err.message : String(err);
+    console.error("[SelfUpdate] Update failed:", msg);
+    return { started: false, error: msg };
+  }
+}

src/update-checker.ts

@@ -206,6 +206,11 @@ export function getUpdateState(): UpdateState | null {
   return _currentState;
 }
 
+/** Whether a full-update pipeline is currently running. */
+export function isUpdateInProgress(): boolean {
+  return _updateInProgress;
+}
+
 function scheduleNextPoll(): void {
   _pollTimer = setTimeout(() => {
     checkForUpdate().catch((err) => {

web/src/App.tsx

@@ -9,14 +9,61 @@ import { CodeExamples } from "./components/CodeExamples";
 import { Footer } from "./components/Footer";
 import { useAccounts } from "../../shared/hooks/use-accounts";
 import { useStatus } from "../../shared/hooks/use-status";
+import { useUpdateStatus } from "../../shared/hooks/use-update-status";
+import { useI18n } from "../../shared/i18n/context";
+
+function useUpdateMessage() {
+  const { t } = useI18n();
+  const update = useUpdateStatus();
+
+  let msg: string | null = null;
+  let color = "text-primary";
+
+  if (!update.checking && update.result) {
+    const parts: string[] = [];
+    const r = update.result;
+
+    if (r.proxy?.error) {
+      parts.push(`Proxy: ${r.proxy.error}`);
+      color = "text-red-500";
+    } else if (r.proxy?.update_applied) {
+      parts.push(t("updateApplied"));
+      color = "text-blue-500";
+    } else if (r.proxy && r.proxy.commits_behind > 0) {
+      parts.push(`Proxy: ${r.proxy.commits_behind} ${t("commits")} ${t("proxyBehind")}`);
+      color = "text-amber-500";
+    }
+
+    if (r.codex?.error) {
+      parts.push(`Codex: ${r.codex.error}`);
+      color = "text-red-500";
+    } else if (r.codex_update_in_progress) {
+      parts.push(t("fingerprintUpdated"));
+    }
+
+    msg = parts.length > 0 ? parts.join(" · ") : t("upToDate");
+  } else if (!update.checking && update.error) {
+    msg = update.error;
+    color = "text-red-500";
+  }
+
+  return { ...update, msg, color };
+}
 
 function Dashboard() {
   const accounts = useAccounts();
   const status = useStatus(accounts.list.length);
+  const update = useUpdateMessage();
 
   return (
     <>
-      <Header onAddAccount={accounts.startAdd} />
+      <Header
+        onAddAccount={accounts.startAdd}
+        onCheckUpdate={update.checkForUpdate}
+        checking={update.checking}
+        updateStatusMsg={update.msg}
+        updateStatusColor={update.color}
+      />
       <main class="flex-grow px-4 md:px-8 lg:px-40 py-8 flex justify-center">
         <div class="flex flex-col w-full max-w-[960px] gap-6">
           <AddAccount
@@ -55,7 +102,7 @@ function Dashboard() {
           />
         </div>
       </main>
-      <Footer />
+      <Footer updateStatus={update.status} />
     </>
   );
 }

web/src/components/Footer.tsx

@@ -1,12 +1,32 @@
 import { useT } from "../../../shared/i18n/context";
+import type { UpdateStatus } from "../../../shared/hooks/use-update-status";
 
-export function Footer() {
+interface FooterProps {
+  updateStatus: UpdateStatus | null;
+}
+
+export function Footer({ updateStatus }: FooterProps) {
   const t = useT();
 
+  const proxyVersion = updateStatus?.proxy.version ?? "...";
+  const proxyCommit = updateStatus?.proxy.commit;
+  const codexVersion = updateStatus?.codex.current_version;
+
   return (
-    <footer class="mt-auto border-t border-gray-200 dark:border-border-dark bg-white dark:bg-card-dark py-6 transition-colors">
-      <div class="container mx-auto px-4 text-center">
-        <p class="text-[0.8rem] text-slate-500 dark:text-text-dim">{t("footer")}</p>
+    <footer class="mt-auto border-t border-gray-200 dark:border-border-dark bg-white dark:bg-card-dark py-5 transition-colors">
+      <div class="container mx-auto px-4 flex flex-col items-center gap-2">
+        {/* Version info */}
+        <div class="flex flex-wrap items-center justify-center gap-x-3 gap-y-1 text-[0.75rem] text-slate-400 dark:text-text-dim font-mono">
+          <span>Proxy v{proxyVersion}{proxyCommit ? ` (${proxyCommit})` : ""}</span>
+          {codexVersion && (
+            <>
+              <span class="text-slate-300 dark:text-border-dark">&middot;</span>
+              <span>Codex Desktop v{codexVersion}</span>
+            </>
+          )}
+        </div>
+        {/* Copyright */}
+        <p class="text-[0.75rem] text-slate-400 dark:text-text-dim">{t("footer")}</p>
       </div>
     </footer>
   );

web/src/components/Header.tsx

@@ -15,9 +15,13 @@ const SVG_SUN = (
 
 interface HeaderProps {
   onAddAccount: () => void;
+  onCheckUpdate: () => void;
+  checking: boolean;
+  updateStatusMsg: string | null;
+  updateStatusColor: string;
 }
 
-export function Header({ onAddAccount }: HeaderProps) {
+export function Header({ onAddAccount, onCheckUpdate, checking, updateStatusMsg, updateStatusColor }: HeaderProps) {
   const { lang, toggleLang, t } = useI18n();
   const { isDark, toggle: toggleTheme } = useTheme();
 
@@ -46,6 +50,37 @@ export function Header({ onAddAccount }: HeaderProps) {
                 <span class="col-start-1 row-start-1">{t("serverOnline")}</span>
               </span>
             </div>
+            {/* Star on GitHub */}
+            <a
+              href="https://github.com/icebear0828/codex-proxy"
+              target="_blank"
+              rel="noopener noreferrer"
+              class="hidden sm:flex items-center gap-1.5 px-3 py-1.5 rounded-full bg-amber-50 border border-amber-200 text-amber-700 dark:bg-amber-900/20 dark:border-amber-700/30 dark:text-amber-400 hover:bg-amber-100 dark:hover:bg-amber-900/40 transition-colors"
+            >
+              <svg class="size-3.5" viewBox="0 0 24 24" fill="currentColor">
+                <path d="M12 2l3.09 6.26L22 9.27l-5 4.87 1.18 6.88L12 17.77l-6.18 3.25L7 14.14 2 9.27l6.91-1.01L12 2z" />
+              </svg>
+              <span class="text-xs font-semibold">{t("starOnGithub")}</span>
+            </a>
+            {/* Check for Updates */}
+            <button
+              onClick={onCheckUpdate}
+              disabled={checking}
+              class="hidden sm:flex items-center gap-1.5 px-3 py-1.5 rounded-full border border-gray-200 dark:border-border-dark text-slate-600 dark:text-text-dim hover:bg-slate-50 dark:hover:bg-border-dark disabled:opacity-50 disabled:cursor-not-allowed transition-colors"
+            >
+              <svg class={`size-3.5 ${checking ? "animate-spin" : ""}`} viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
+                <path stroke-linecap="round" stroke-linejoin="round" d="M16.023 9.348h4.992v-.001M2.985 19.644v-4.992m0 0h4.992m-4.992 0l3.181 3.183a8.25 8.25 0 0013.803-3.7M4.031 9.865a8.25 8.25 0 0113.803-3.7l3.181 3.182M20.985 4.356v4.992" />
+              </svg>
+              <span class="text-xs font-semibold">
+                {checking ? t("checkingUpdates") : t("checkForUpdates")}
+              </span>
+            </button>
+            {/* Update status message */}
+            {updateStatusMsg && !checking && (
+              <span class={`hidden sm:inline text-xs font-medium ${updateStatusColor}`}>
+                {updateStatusMsg}
+              </span>
+            )}
             {/* Language Toggle */}
             <button
               onClick={toggleLang}

web/vite.config.ts

@@ -22,6 +22,7 @@ export default defineConfig({
       "/auth": "http://localhost:8080",
       "/health": "http://localhost:8080",
       "/debug": "http://localhost:8080",
+      "/admin": "http://localhost:8080",
     },
   },
 });