feat: auto-release pipeline + multi-mode update system + commit hash display

- sync-electron.yml: auto bump patch version + create tag after merge, concurrency group
- release.yml: replace CHANGELOG extraction with GitHub auto-generated release notes
- self-update.ts: support git/docker/electron deploy modes, GitHub Releases API, periodic checker
- Header: show commit hash in status badge, expandable update panel with changelog
- use-update-status: add applyUpdate, mode/commits/release fields

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

.github/workflows/release.yml

@@ -0,0 +1,93 @@
+name: Release Electron App
+
+on:
+  push:
+    tags:
+      - "v*"
+  workflow_dispatch:
+
+permissions:
+  contents: write
+
+jobs:
+  build:
+    strategy:
+      fail-fast: false
+      matrix:
+        include:
+          - os: windows-latest
+            platform: win
+            artifact: windows
+          - os: macos-latest
+            platform: mac
+            artifact: macos
+          - os: ubuntu-latest
+            platform: linux
+            artifact: linux
+
+    runs-on: ${{ matrix.os }}
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Setup Node.js
+        uses: actions/setup-node@v4
+        with:
+          node-version: 20
+          cache: npm
+
+      - name: Install root dependencies
+        run: npm ci --ignore-scripts
+
+      - name: Setup curl-impersonate
+        run: npx tsx scripts/setup-curl.ts
+        env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
+
+      - name: Install web dependencies
+        run: cd web && npm ci
+
+      - name: Install desktop dependencies
+        run: cd desktop && npm ci
+
+      - name: Build app
+        run: npm run app:build
+
+      - name: Pack (${{ matrix.platform }})
+        run: npx electron-builder --config electron-builder.yml --${{ matrix.platform }} --publish never
+
+      - name: Upload artifacts
+        uses: actions/upload-artifact@v4
+        with:
+          name: release-${{ matrix.artifact }}
+          path: |
+            release/*.exe
+            release/*.dmg
+            release/*.AppImage
+            release/*.yml
+            release/*.yaml
+          if-no-files-found: ignore
+
+  release:
+    needs: build
+    runs-on: ubuntu-latest
+    if: startsWith(github.ref, 'refs/tags/v')
+
+    steps:
+      - name: Checkout
+        uses: actions/checkout@v4
+
+      - name: Download all artifacts
+        uses: actions/download-artifact@v4
+        with:
+          path: artifacts
+          merge-multiple: true
+
+      - name: Create GitHub Release
+        uses: softprops/action-gh-release@v2
+        with:
+          generate_release_notes: true
+          draft: false
+          prerelease: false
+          files: artifacts/*

.github/workflows/sync-electron.yml

@@ -5,6 +5,10 @@ on:
     branches: [master]
   workflow_dispatch:
 
+concurrency:
+  group: sync-electron
+  cancel-in-progress: true
+
 permissions:
   contents: write
   issues: write
@@ -29,9 +33,65 @@ jobs:
             echo "CONFLICT=true" >> "$GITHUB_ENV"
           }
 
-      - name: Push if merged successfully
+      - name: Auto bump + tag if new commits
         if: env.CONFLICT != 'true'
-        run: git push origin electron
+        run: |
+          # Find last version tag
+          LAST_TAG=$(git describe --tags --abbrev=0 --match "v*" 2>/dev/null || echo "")
+          if [ -z "$LAST_TAG" ]; then
+            echo "No previous tag found, skipping auto-bump"
+            echo "BUMP=false" >> "$GITHUB_ENV"
+            exit 0
+          fi
+
+          # Check for new non-merge commits since last tag
+          NEW_COMMITS=$(git log "${LAST_TAG}..HEAD" --no-merges --oneline | wc -l)
+          if [ "$NEW_COMMITS" -eq 0 ]; then
+            echo "No new non-merge commits since $LAST_TAG, skipping bump"
+            echo "BUMP=false" >> "$GITHUB_ENV"
+            exit 0
+          fi
+
+          echo "Found $NEW_COMMITS new commit(s) since $LAST_TAG"
+
+          # Parse current version and bump patch
+          CURRENT="${LAST_TAG#v}"
+          IFS='.' read -r MAJOR MINOR PATCH <<< "$CURRENT"
+          NEW_PATCH=$((PATCH + 1))
+          NEW_VERSION="${MAJOR}.${MINOR}.${NEW_PATCH}"
+          NEW_TAG="v${NEW_VERSION}"
+
+          # Check tag doesn't already exist (concurrent protection)
+          if git rev-parse "$NEW_TAG" >/dev/null 2>&1; then
+            echo "Tag $NEW_TAG already exists, skipping"
+            echo "BUMP=false" >> "$GITHUB_ENV"
+            exit 0
+          fi
+
+          # Bump version in package.json
+          node -e "
+            const fs = require('fs');
+            const pkg = JSON.parse(fs.readFileSync('package.json', 'utf-8'));
+            pkg.version = '${NEW_VERSION}';
+            fs.writeFileSync('package.json', JSON.stringify(pkg, null, 2) + '\n');
+          "
+
+          git add package.json
+          git commit -m "chore: bump version to ${NEW_VERSION}"
+          git tag -a "$NEW_TAG" -m "Release ${NEW_TAG}"
+
+          echo "BUMP=true" >> "$GITHUB_ENV"
+          echo "NEW_TAG=$NEW_TAG" >> "$GITHUB_ENV"
+          echo "Bumped to $NEW_VERSION, tagged $NEW_TAG"
+
+      - name: Push electron branch (with tags if bumped)
+        if: env.CONFLICT != 'true'
+        run: |
+          if [ "$BUMP" = "true" ]; then
+            git push origin electron --follow-tags
+          else
+            git push origin electron
+          fi
 
       - name: Create issue on conflict
         if: env.CONFLICT == 'true'

shared/hooks/use-update-status.ts

@@ -5,7 +5,11 @@ export interface UpdateStatus {
     version: string;
     commit: string | null;
     can_self_update: boolean;
+    mode: "git" | "docker" | "electron";
     commits_behind: number | null;
+    commits: { hash: string; message: string }[];
+    release: { version: string; body: string; url: string } | null;
+    update_available: boolean;
     update_in_progress: boolean;
   };
   codex: {
@@ -24,7 +28,10 @@ export interface CheckResult {
     commits_behind: number;
     current_commit: string | null;
     latest_commit: string | null;
-    update_applied?: boolean;
+    commits: { hash: string; message: string }[];
+    release: { version: string; body: string; url: string } | null;
+    update_available: boolean;
+    mode: "git" | "docker" | "electron";
     error?: string;
   };
   codex?: {
@@ -43,12 +50,13 @@ export function useUpdateStatus() {
   const [checking, setChecking] = useState(false);
   const [result, setResult] = useState<CheckResult | null>(null);
   const [error, setError] = useState<string | null>(null);
+  const [applying, setApplying] = useState(false);
 
   const load = useCallback(async () => {
     try {
       const resp = await fetch("/admin/update-status");
       if (resp.ok) {
-        setStatus(await resp.json());
+        setStatus(await resp.json() as UpdateStatus);
       }
     } catch { /* ignore */ }
   }, []);
@@ -61,12 +69,11 @@ export function useUpdateStatus() {
     setResult(null);
     try {
       const resp = await fetch("/admin/check-update", { method: "POST" });
-      const data: CheckResult = await resp.json();
+      const data = await resp.json() as CheckResult;
       if (!resp.ok) {
         setError("Check failed");
       } else {
         setResult(data);
-        // Refresh status after check
         await load();
       }
     } catch (err) {
@@ -76,5 +83,23 @@ export function useUpdateStatus() {
     }
   }, [load]);
 
-  return { status, checking, result, error, checkForUpdate };
+  const applyUpdate = useCallback(async () => {
+    setApplying(true);
+    setError(null);
+    try {
+      const resp = await fetch("/admin/apply-update", { method: "POST" });
+      const data = await resp.json() as { started: boolean; error?: string };
+      if (!resp.ok || !data.started) {
+        setError(data.error ?? "Apply failed");
+      } else {
+        await load();
+      }
+    } catch (err) {
+      setError(err instanceof Error ? err.message : "Network error");
+    } finally {
+      setApplying(false);
+    }
+  }, [load]);
+
+  return { status, checking, result, error, checkForUpdate, applyUpdate, applying };
 }

shared/i18n/translations.ts

@@ -141,6 +141,14 @@ export const translations = {
     speed: "Speed",
     speedStandard: "Standard",
     speedFast: "Fast",
+    updateAvailable: "Update Available",
+    updateNow: "Update Now",
+    applyingUpdate: "Updating...",
+    viewChanges: "View Changes",
+    hideChanges: "Hide",
+    newVersion: "New version",
+    dockerUpdateCmd: "Run to update:",
+    downloadUpdate: "Download",
   },
   zh: {
     serverOnline: "\u670d\u52a1\u8fd0\u884c\u4e2d",
@@ -287,6 +295,14 @@ export const translations = {
     speed: "\u901f\u5ea6",
     speedStandard: "\u6807\u51c6",
     speedFast: "\u5feb\u901f",
+    updateAvailable: "\u6709\u53ef\u7528\u66f4\u65b0",
+    updateNow: "\u7acb\u5373\u66f4\u65b0",
+    applyingUpdate: "\u66f4\u65b0\u4e2d...",
+    viewChanges: "\u67e5\u770b\u53d8\u66f4",
+    hideChanges: "\u6536\u8d77",
+    newVersion: "\u65b0\u7248\u672c",
+    dockerUpdateCmd: "\u6267\u884c\u66f4\u65b0\u547d\u4ee4\uff1a",
+    downloadUpdate: "\u4e0b\u8f7d",
   },
 } as const;
 

src/index.ts

@@ -19,6 +19,7 @@ import { ProxyPool } from "./proxy/proxy-pool.js";
 import { createProxyRoutes } from "./routes/proxies.js";
 import { createResponsesRoutes } from "./routes/responses.js";
 import { startUpdateChecker, stopUpdateChecker } from "./update-checker.js";
+import { startProxyUpdateChecker, stopProxyUpdateChecker } from "./self-update.js";
 import { initProxy } from "./tls/curl-binary.js";
 import { initTransport } from "./tls/transport.js";
 import { loadStaticModels } from "./models/model-store.js";
@@ -117,6 +118,7 @@ export async function startServer(options?: StartOptions): Promise<ServerHandle>
 
   // Start background update checker
   startUpdateChecker();
+  startProxyUpdateChecker();
 
   // Start background model refresh (requires auth to be ready)
   startModelRefresh(accountPool, cookieJar, proxyPool);
@@ -134,6 +136,7 @@ export async function startServer(options?: StartOptions): Promise<ServerHandle>
     return new Promise((resolve) => {
       server.close(() => {
         stopUpdateChecker();
+        stopProxyUpdateChecker();
         stopModelRefresh();
         refreshScheduler.destroy();
         proxyPool.destroy();

src/routes/web.ts

@@ -6,7 +6,7 @@ import type { AccountPool } from "../auth/account-pool.js";
 import { getConfig, getFingerprint } from "../config.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";
+import { getProxyInfo, canSelfUpdate, checkProxySelfUpdate, applyProxySelfUpdate, isProxyUpdateInProgress, getCachedProxyUpdateResult, getDeployMode } from "../self-update.js";
 
 export function createWebRoutes(accountPool: AccountPool): Hono {
   const app = new Hono();
@@ -127,13 +127,18 @@ export function createWebRoutes(accountPool: AccountPool): Hono {
   app.get("/admin/update-status", (c) => {
     const proxyInfo = getProxyInfo();
     const codexState = getUpdateState();
+    const cached = getCachedProxyUpdateResult();
 
     return c.json({
       proxy: {
         version: proxyInfo.version,
         commit: proxyInfo.commit,
         can_self_update: canSelfUpdate(),
-        commits_behind: null as number | null,
+        mode: getDeployMode(),
+        commits_behind: cached?.commitsBehind ?? null,
+        commits: cached?.commits ?? [],
+        release: cached?.release ? { version: cached.release.version, body: cached.release.body, url: cached.release.url } : null,
+        update_available: cached?.updateAvailable ?? false,
         update_in_progress: isProxyUpdateInProgress(),
       },
       codex: {
@@ -150,34 +155,42 @@ export function createWebRoutes(accountPool: AccountPool): Hono {
 
   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 };
+      proxy?: {
+        commits_behind: number;
+        current_commit: string | null;
+        latest_commit: string | null;
+        commits: Array<{ hash: string; message: string }>;
+        release: { version: string; body: string; url: string } | null;
+        update_available: boolean;
+        mode: string;
+        error?: string;
+      };
       codex?: { update_available: boolean; current_version: string; latest_version: string | null; version_changed?: boolean; 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),
-        };
-      }
+    // 1. Proxy update check (all modes)
+    try {
+      const proxyResult = await checkProxySelfUpdate();
+      results.proxy = {
+        commits_behind: proxyResult.commitsBehind,
+        current_commit: proxyResult.currentCommit,
+        latest_commit: proxyResult.latestCommit,
+        commits: proxyResult.commits,
+        release: proxyResult.release ? { version: proxyResult.release.version, body: proxyResult.release.body, url: proxyResult.release.url } : null,
+        update_available: proxyResult.updateAvailable,
+        mode: proxyResult.mode,
+      };
+    } catch (err) {
+      results.proxy = {
+        commits_behind: 0,
+        current_commit: null,
+        latest_commit: null,
+        commits: [],
+        release: null,
+        update_available: false,
+        mode: getDeployMode(),
+        error: err instanceof Error ? err.message : String(err),
+      };
     }
 
     // 2. Codex fingerprint check
@@ -208,5 +221,14 @@ export function createWebRoutes(accountPool: AccountPool): Hono {
     });
   });
 
+  app.post("/admin/apply-update", async (c) => {
+    if (!canSelfUpdate()) {
+      c.status(400);
+      return c.json({ started: false, error: "Self-update not available in this deploy mode" });
+    }
+    const result = await applyProxySelfUpdate();
+    return c.json(result);
+  });
+
   return app;
 }

src/self-update.ts

@@ -1,6 +1,8 @@
 /**
- * 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.
+ * Proxy self-update — detects available updates in three deployment modes:
+ * - CLI (git): git fetch + commit log
+ * - Docker (no .git): GitHub Releases API
+ * - Electron (embedded): GitHub Releases API
  */
 
 import { execFile, execFileSync } from "child_process";
@@ -11,39 +13,64 @@ import { isEmbedded } from "./paths.js";
 
 const execFileAsync = promisify(execFile);
 
+const GITHUB_REPO = "icebear0828/codex-proxy";
+const CHECK_INTERVAL_MS = 6 * 60 * 60 * 1000; // 6 hours
+const INITIAL_DELAY_MS = 10_000; // 10 seconds after startup
+
 export interface ProxyInfo {
   version: string;
   commit: string | null;
 }
 
+export interface CommitInfo {
+  hash: string;
+  message: string;
+}
+
+export interface GitHubReleaseInfo {
+  version: string;
+  tag: string;
+  body: string;
+  url: string;
+  publishedAt: string;
+}
+
+export type DeployMode = "git" | "docker" | "electron";
+
 export interface ProxySelfUpdateResult {
   commitsBehind: number;
   currentCommit: string | null;
   latestCommit: string | null;
+  commits: CommitInfo[];
+  release: GitHubReleaseInfo | null;
+  updateAvailable: boolean;
+  mode: DeployMode;
 }
 
 let _proxyUpdateInProgress = false;
 let _gitAvailable: boolean | null = null;
+let _cachedResult: ProxySelfUpdateResult | null = null;
+let _checkTimer: ReturnType<typeof setInterval> | null = null;
+let _initialTimer: ReturnType<typeof setTimeout> | null = null;
+let _checking = false;
 
 /** 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"));
+    const pkg = JSON.parse(readFileSync(resolve(process.cwd(), "package.json"), "utf-8")) as { version?: string };
     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 */ }
-  }
+  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 };
 }
@@ -53,13 +80,11 @@ 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(),
@@ -74,51 +99,137 @@ export function canSelfUpdate(): boolean {
   return _gitAvailable;
 }
 
+/** Determine deployment mode. */
+export function getDeployMode(): DeployMode {
+  if (isEmbedded()) return "electron";
+  if (canSelfUpdate()) return "git";
+  return "docker";
+}
+
 /** 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();
+/** Return cached proxy update result (set by periodic checker or manual check). */
+export function getCachedProxyUpdateResult(): ProxySelfUpdateResult | null {
+  return _cachedResult;
+}
 
-  // Get current commit
-  let currentCommit: string | null = null;
+/** Get commit log between HEAD and origin/master. */
+async function getCommitLog(cwd: string): Promise<CommitInfo[]> {
   try {
-    const { stdout } = await execFileAsync("git", ["rev-parse", "--short", "HEAD"], { cwd, timeout: 5000 });
-    currentCommit = stdout.trim() || null;
-  } catch { /* ignore */ }
+    const { stdout } = await execFileAsync(
+      "git", ["log", "HEAD..origin/master", "--oneline", "--format=%h %s"],
+      { cwd, timeout: 10000 },
+    );
+    return stdout.trim().split("\n")
+      .filter((line) => line.length > 0)
+      .map((line) => {
+        const spaceIdx = line.indexOf(" ");
+        return {
+          hash: line.substring(0, spaceIdx),
+          message: line.substring(spaceIdx + 1),
+        };
+      });
+  } catch {
+    return [];
+  }
+}
 
-  // Fetch latest
+/** Check GitHub Releases API for the latest version. */
+async function checkGitHubRelease(): Promise<GitHubReleaseInfo | null> {
   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 };
+    const resp = await fetch(`https://api.github.com/repos/${GITHUB_REPO}/releases/latest`, {
+      headers: { Accept: "application/vnd.github.v3+json" },
+      signal: AbortSignal.timeout(15000),
+    });
+    if (!resp.ok) return null;
+    const data = await resp.json() as {
+      tag_name?: string;
+      body?: string | null;
+      html_url?: string;
+      published_at?: string;
+    };
+    return {
+      version: String(data.tag_name ?? "").replace(/^v/, ""),
+      tag: String(data.tag_name ?? ""),
+      body: String(data.body ?? ""),
+      url: String(data.html_url ?? ""),
+      publishedAt: String(data.published_at ?? ""),
+    };
+  } catch {
+    return null;
   }
+}
 
-  // 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;
+/** Fetch latest from origin and check how many commits behind. */
+export async function checkProxySelfUpdate(): Promise<ProxySelfUpdateResult> {
+  const mode = getDeployMode();
 
-    const { stdout: latestOut } = await execFileAsync(
-      "git", ["rev-parse", "--short", "origin/master"], { cwd, timeout: 5000 },
-    );
-    latestCommit = latestOut.trim() || null;
-  } catch { /* ignore */ }
+  if (mode === "git") {
+    const cwd = process.cwd();
+
+    let currentCommit: string | null = null;
+    try {
+      const { stdout } = await execFileAsync("git", ["rev-parse", "--short", "HEAD"], { cwd, timeout: 5000 });
+      currentCommit = stdout.trim() || null;
+    } catch { /* ignore */ }
+
+    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);
+      const result: ProxySelfUpdateResult = {
+        commitsBehind: 0, currentCommit, latestCommit: currentCommit,
+        commits: [], release: null, updateAvailable: false, mode,
+      };
+      _cachedResult = result;
+      return result;
+    }
+
+    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 */ }
+
+    const commits = commitsBehind > 0 ? await getCommitLog(cwd) : [];
 
-  return { commitsBehind, currentCommit, latestCommit };
+    const result: ProxySelfUpdateResult = {
+      commitsBehind, currentCommit, latestCommit,
+      commits, release: null,
+      updateAvailable: commitsBehind > 0, mode,
+    };
+    _cachedResult = result;
+    return result;
+  }
+
+  // Docker or Electron — GitHub Releases API
+  const release = await checkGitHubRelease();
+  const currentVersion = getProxyInfo().version;
+  const updateAvailable = release !== null && release.version !== currentVersion;
+
+  const result: ProxySelfUpdateResult = {
+    commitsBehind: 0, currentCommit: null, latestCommit: null,
+    commits: [], release: updateAvailable ? release : null,
+    updateAvailable, mode,
+  };
+  _cachedResult = result;
+  return result;
 }
 
 /**
  * Apply proxy self-update: git pull + npm install + npm run build.
- * Runs in background. Returns immediately; check isProxyUpdateInProgress() for status.
+ * Only works in git (CLI) mode.
  */
 export async function applyProxySelfUpdate(): Promise<{ started: boolean; error?: string }> {
   if (_proxyUpdateInProgress) {
@@ -148,3 +259,39 @@ export async function applyProxySelfUpdate(): Promise<{ started: boolean; error?
     return { started: false, error: msg };
   }
 }
+
+/** Run a background check (guards against concurrent execution). */
+async function runCheck(): Promise<void> {
+  if (_checking) return;
+  _checking = true;
+  try {
+    await checkProxySelfUpdate();
+  } catch (err) {
+    console.warn("[SelfUpdate] Periodic check failed:", err instanceof Error ? err.message : err);
+  } finally {
+    _checking = false;
+  }
+}
+
+/** Start periodic proxy update checking (initial check after 10s, then every 6h). */
+export function startProxyUpdateChecker(): void {
+  _initialTimer = setTimeout(() => {
+    runCheck();
+  }, INITIAL_DELAY_MS);
+
+  _checkTimer = setInterval(() => {
+    runCheck();
+  }, CHECK_INTERVAL_MS);
+}
+
+/** Stop periodic proxy update checking. */
+export function stopProxyUpdateChecker(): void {
+  if (_initialTimer) {
+    clearTimeout(_initialTimer);
+    _initialTimer = null;
+  }
+  if (_checkTimer) {
+    clearInterval(_checkTimer);
+    _checkTimer = null;
+  }
+}

vitest.config.ts

@@ -1,8 +1,21 @@
 import { defineConfig } from "vitest/config";
+import { resolve } from "path";
 
 export default defineConfig({
+  resolve: {
+    alias: {
+      "@src": resolve(__dirname, "src"),
+      "@helpers": resolve(__dirname, "tests/_helpers"),
+      "@fixtures": resolve(__dirname, "tests/_fixtures"),
+    },
+  },
   test: {
-    root: "src",
     environment: "node",
+    include: [
+      "src/**/*.{test,spec}.ts",
+      "tests/unit/**/*.{test,spec}.ts",
+      "tests/integration/**/*.{test,spec}.ts",
+      "tests/e2e/**/*.{test,spec}.ts",
+    ],
   },
 });

web/src/App.tsx

@@ -30,11 +30,8 @@ function useUpdateMessage() {
     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")}`);
+    } else if (r.proxy?.update_available) {
+      parts.push(t("updateAvailable"));
       color = "text-amber-500";
     }
 
@@ -54,7 +51,18 @@ function useUpdateMessage() {
     color = "text-red-500";
   }
 
-  return { ...update, msg, color };
+  const proxyUpdate = update.status?.proxy.update_available
+    ? {
+        mode: update.status.proxy.mode,
+        updateAvailable: true as const,
+        commits: update.status.proxy.commits,
+        release: update.status.proxy.release,
+        onApply: update.applyUpdate,
+        applying: update.applying,
+      }
+    : null;
+
+  return { ...update, msg, color, proxyUpdate };
 }
 
 function Dashboard() {
@@ -77,6 +85,8 @@ function Dashboard() {
         updateStatusMsg={update.msg}
         updateStatusColor={update.color}
         version={update.status?.proxy.version ?? null}
+        commit={update.status?.proxy.commit ?? null}
+        proxyUpdate={update.proxyUpdate}
       />
       <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">
@@ -164,7 +174,9 @@ function ProxySettingsPage() {
         updateStatusMsg={update.msg}
         updateStatusColor={update.color}
         version={update.status?.proxy.version ?? null}
+        commit={update.status?.proxy.commit ?? null}
         isProxySettings
+        proxyUpdate={update.proxyUpdate}
       />
       <ProxySettings />
     </>

web/src/components/Header.tsx

@@ -1,3 +1,4 @@
+import { useState } from "preact/hooks";
 import { useI18n } from "../../../shared/i18n/context";
 import { useTheme } from "../../../shared/theme/context";
 
@@ -13,6 +14,15 @@ const SVG_SUN = (
   </svg>
 );
 
+export interface ProxyUpdateInfo {
+  mode: "git" | "docker" | "electron";
+  updateAvailable: boolean;
+  commits: { hash: string; message: string }[];
+  release: { version: string; body: string; url: string } | null;
+  onApply: () => void;
+  applying: boolean;
+}
+
 interface HeaderProps {
   onAddAccount: () => void;
   onCheckUpdate: () => void;
@@ -20,12 +30,15 @@ interface HeaderProps {
   updateStatusMsg: string | null;
   updateStatusColor: string;
   version: string | null;
+  commit?: string | null;
   isProxySettings?: boolean;
+  proxyUpdate?: ProxyUpdateInfo | null;
 }
 
-export function Header({ onAddAccount, onCheckUpdate, checking, updateStatusMsg, updateStatusColor, version, isProxySettings }: HeaderProps) {
+export function Header({ onAddAccount, onCheckUpdate, checking, updateStatusMsg, updateStatusColor, version, commit, isProxySettings, proxyUpdate }: HeaderProps) {
   const { lang, toggleLang, t } = useI18n();
   const { isDark, toggle: toggleTheme } = useTheme();
+  const [showChangelog, setShowChangelog] = useState(false);
 
   return (
     <header class="sticky top-0 z-50 w-full bg-white dark:bg-card-dark border-b border-gray-200 dark:border-border-dark shadow-sm transition-colors">
@@ -55,7 +68,7 @@ export function Header({ onAddAccount, onCheckUpdate, checking, updateStatusMsg,
             )}
           </div>
           {/* Actions */}
-          <div class="flex items-center gap-3">
+          <div class="flex items-center gap-2">
             <div class="hidden sm:flex items-center gap-2 px-3 py-1.5 rounded-full bg-primary/10 border border-primary/20">
               <span class="relative flex h-2.5 w-2.5">
                 <span class="animate-ping absolute inline-flex h-full w-full rounded-full bg-primary opacity-75" />
@@ -68,13 +81,16 @@ export function Header({ onAddAccount, onCheckUpdate, checking, updateStatusMsg,
               {version && (
                 <span class="text-[0.65rem] font-mono text-primary/70">v{version}</span>
               )}
+              {commit && (
+                <span class="text-[0.6rem] font-mono text-primary/40">{commit.slice(0, 7)}</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"
+              class="hidden md: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" />
@@ -85,7 +101,7 @@ export function Header({ onAddAccount, onCheckUpdate, checking, updateStatusMsg,
             <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"
+              class="hidden md: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" />
@@ -98,7 +114,7 @@ export function Header({ onAddAccount, onCheckUpdate, checking, updateStatusMsg,
             {updateStatusMsg && !checking && (
               <button
                 onClick={onCheckUpdate}
-                class={`hidden sm:inline text-xs font-medium ${updateStatusColor} hover:underline`}
+                class={`hidden md:inline text-xs font-medium ${updateStatusColor} hover:underline`}
               >
                 {updateStatusMsg}
               </button>
@@ -124,7 +140,7 @@ export function Header({ onAddAccount, onCheckUpdate, checking, updateStatusMsg,
               <>
                 <a
                   href="#/proxy-settings"
-                  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 transition-colors"
+                  class="hidden md: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 transition-colors"
                 >
                   <svg class="size-3.5" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2">
                     <path stroke-linecap="round" stroke-linejoin="round" d="M10.5 6h9.75M10.5 6a1.5 1.5 0 11-3 0m3 0a1.5 1.5 0 10-3 0M3.75 6H7.5m3 12h9.75m-9.75 0a1.5 1.5 0 01-3 0m3 0a1.5 1.5 0 00-3 0m-3.75 0H7.5m9-6h3.75m-3.75 0a1.5 1.5 0 01-3 0m3 0a1.5 1.5 0 00-3 0m-9.75 0h9.75" />
@@ -148,6 +164,76 @@ export function Header({ onAddAccount, onCheckUpdate, checking, updateStatusMsg,
           </div>
         </div>
       </div>
+      {/* Expandable update panel */}
+      {proxyUpdate && proxyUpdate.updateAvailable && (
+        <div class="border-t border-amber-200 dark:border-amber-700/30 bg-amber-50/80 dark:bg-amber-900/10">
+          <div class="px-4 md:px-8 lg:px-40 flex justify-center">
+            <div class="w-full max-w-[960px] py-2">
+              <div class="flex items-center justify-between">
+                <span class="text-xs font-medium text-amber-700 dark:text-amber-400">
+                  {proxyUpdate.mode === "git"
+                    ? `${proxyUpdate.commits.length} ${t("commits")} ${t("proxyBehind")}`
+                    : `${t("newVersion")} v${proxyUpdate.release?.version}`}
+                </span>
+                <button
+                  onClick={() => setShowChangelog(!showChangelog)}
+                  class="text-xs font-medium text-amber-600 dark:text-amber-400 hover:underline"
+                >
+                  {showChangelog ? t("hideChanges") : t("viewChanges")}
+                </button>
+              </div>
+              {showChangelog && (
+                <div class="mt-2">
+                  {proxyUpdate.mode === "git" ? (
+                    <>
+                      <ul class="space-y-0.5 text-xs text-slate-600 dark:text-text-dim max-h-48 overflow-y-auto">
+                        {proxyUpdate.commits.map((c) => (
+                          <li key={c.hash} class="flex gap-2">
+                            <code class="text-primary/70 shrink-0">{c.hash}</code>
+                            <span>{c.message}</span>
+                          </li>
+                        ))}
+                      </ul>
+                      <button
+                        onClick={proxyUpdate.onApply}
+                        disabled={proxyUpdate.applying}
+                        class="mt-2 px-3 py-1.5 text-xs font-semibold bg-primary text-white rounded-md hover:bg-primary-hover disabled:opacity-50 transition-colors"
+                      >
+                        {proxyUpdate.applying ? t("applyingUpdate") : t("updateNow")}
+                      </button>
+                    </>
+                  ) : (
+                    <>
+                      {proxyUpdate.release && (
+                        <pre class="text-xs text-slate-600 dark:text-text-dim whitespace-pre-wrap max-h-48 overflow-y-auto mb-2">
+                          {proxyUpdate.release.body}
+                        </pre>
+                      )}
+                      {proxyUpdate.mode === "docker" ? (
+                        <div class="flex items-center gap-2">
+                          <span class="text-xs text-slate-500 dark:text-text-dim">{t("dockerUpdateCmd")}</span>
+                          <code class="text-xs bg-slate-100 dark:bg-bg-dark px-2 py-0.5 rounded font-mono select-all">
+                            docker compose up -d --build
+                          </code>
+                        </div>
+                      ) : (
+                        <a
+                          href={proxyUpdate.release?.url}
+                          target="_blank"
+                          rel="noopener noreferrer"
+                          class="inline-flex items-center gap-1.5 px-3 py-1.5 text-xs font-semibold bg-primary text-white rounded-md hover:bg-primary-hover transition-colors"
+                        >
+                          {t("downloadUpdate")}
+                        </a>
+                      )}
+                    </>
+                  )}
+                </div>
+              )}
+            </div>
+          </div>
+        </div>
+      )}
     </header>
   );
 }