fix: Address code review feedback for OAuth SSO

- Add proper lifecycle management for state cleanup interval - Fix host header injection vulnerability by validating forwarded headers - Add type safety for GitHub API responses - Add stopStateCleanup function for test cleanup - Document scaling limitations of in-memory state store Co-authored-by: samanhappy <2755122+samanhappy@users.noreply.github.com>
feat: Add OAuth 2.0 / OIDC SSO login support
2025-12-31 20:00:00 -05:00 · 2025-12-31 15:23:14 +00:00 · 2025-12-31 15:17:07 +00:00 · 2025-12-31 14:57:01 +00:00
25 changed files with 1416 additions and 602 deletions
--- a/frontend/src/App.tsx
+++ b/frontend/src/App.tsx
@@ -8,6 +8,7 @@ import { SettingsProvider } from './contexts/SettingsContext';
 import MainLayout from './layouts/MainLayout';
 import ProtectedRoute from './components/ProtectedRoute';
 import LoginPage from './pages/LoginPage';
+import OAuthCallbackPage from './pages/OAuthCallbackPage';
 import DashboardPage from './pages/Dashboard';
 import ServersPage from './pages/ServersPage';
 import GroupsPage from './pages/GroupsPage';
@@ -35,6 +36,7 @@ function App() {
                <Routes>
                  {/* 公共路由 */}
                  <Route path="/login" element={<LoginPage />} />
+                  <Route path="/oauth-callback" element={<OAuthCallbackPage />} />

                  {/* 受保护的路由，使用 MainLayout 作为布局容器 */}
                  <Route element={<ProtectedRoute />}>
--- a/frontend/src/pages/LoginPage.tsx
+++ b/frontend/src/pages/LoginPage.tsx
@@ -1,11 +1,12 @@
-import React, { useState, useMemo, useCallback } from 'react';
+import React, { useState, useMemo, useCallback, useEffect } from 'react';
 import { useLocation, useNavigate } from 'react-router-dom';
 import { useTranslation } from 'react-i18next';
 import { useAuth } from '../contexts/AuthContext';
-import { getToken } from '../services/authService';
+import { getToken, getOAuthSsoConfig, initiateOAuthSsoLogin } from '../services/authService';
 import ThemeSwitch from '@/components/ui/ThemeSwitch';
 import LanguageSwitch from '@/components/ui/LanguageSwitch';
 import DefaultPasswordWarningModal from '@/components/ui/DefaultPasswordWarningModal';
+import { OAuthSsoConfig, OAuthSsoProvider } from '../types';

 const sanitizeReturnUrl = (value: string | null): string | null => {
  if (!value) {
@@ -29,6 +30,44 @@ const sanitizeReturnUrl = (value: string | null): string | null => {
  }
 };

+// Provider icon component
+const ProviderIcon: React.FC<{ type: string; className?: string }> = ({ type, className = 'w-5 h-5' }) => {
+  switch (type) {
+    case 'google':
+      return (
+        <svg className={className} viewBox="0 0 24 24" fill="currentColor">
+          <path d="M22.56 12.25c0-.78-.07-1.53-.2-2.25H12v4.26h5.92c-.26 1.37-1.04 2.53-2.21 3.31v2.77h3.57c2.08-1.92 3.28-4.74 3.28-8.09z" fill="#4285F4"/>
+          <path d="M12 23c2.97 0 5.46-.98 7.28-2.66l-3.57-2.77c-.98.66-2.23 1.06-3.71 1.06-2.86 0-5.29-1.93-6.16-4.53H2.18v2.84C3.99 20.53 7.7 23 12 23z" fill="#34A853"/>
+          <path d="M5.84 14.09c-.22-.66-.35-1.36-.35-2.09s.13-1.43.35-2.09V7.07H2.18C1.43 8.55 1 10.22 1 12s.43 3.45 1.18 4.93l2.85-2.22.81-.62z" fill="#FBBC05"/>
+          <path d="M12 5.38c1.62 0 3.06.56 4.21 1.64l3.15-3.15C17.45 2.09 14.97 1 12 1 7.7 1 3.99 3.47 2.18 7.07l3.66 2.84c.87-2.6 3.3-4.53 6.16-4.53z" fill="#EA4335"/>
+        </svg>
+      );
+    case 'microsoft':
+      return (
+        <svg className={className} viewBox="0 0 24 24" fill="currentColor">
+          <path d="M11.4 11.4H2V2h9.4v9.4z" fill="#F25022"/>
+          <path d="M22 11.4h-9.4V2H22v9.4z" fill="#7FBA00"/>
+          <path d="M11.4 22H2v-9.4h9.4V22z" fill="#00A4EF"/>
+          <path d="M22 22h-9.4v-9.4H22V22z" fill="#FFB900"/>
+        </svg>
+      );
+    case 'github':
+      return (
+        <svg className={className} viewBox="0 0 24 24" fill="currentColor">
+          <path fillRule="evenodd" clipRule="evenodd" d="M12 2C6.477 2 2 6.477 2 12c0 4.42 2.865 8.17 6.839 9.49.5.092.682-.217.682-.482 0-.237-.009-.866-.013-1.7-2.782.604-3.369-1.34-3.369-1.34-.454-1.156-1.11-1.464-1.11-1.464-.908-.62.069-.608.069-.608 1.003.07 1.531 1.03 1.531 1.03.892 1.529 2.341 1.087 2.91.831.092-.646.35-1.086.636-1.336-2.22-.253-4.555-1.11-4.555-4.943 0-1.091.39-1.984 1.029-2.683-.103-.253-.446-1.27.098-2.647 0 0 .84-.269 2.75 1.025A9.578 9.578 0 0112 6.836c.85.004 1.705.115 2.504.337 1.909-1.294 2.747-1.025 2.747-1.025.546 1.377.203 2.394.1 2.647.64.699 1.028 1.592 1.028 2.683 0 3.842-2.339 4.687-4.566 4.935.359.309.678.919.678 1.852 0 1.336-.012 2.415-.012 2.743 0 .267.18.579.688.481C19.137 20.167 22 16.418 22 12c0-5.523-4.477-10-10-10z"/>
+        </svg>
+      );
+    default:
+      return (
+        <svg className={className} viewBox="0 0 24 24" fill="none" stroke="currentColor" strokeWidth="2">
+          <path d="M15 3h4a2 2 0 0 1 2 2v14a2 2 0 0 1-2 2h-4"/>
+          <polyline points="10 17 15 12 10 7"/>
+          <line x1="15" y1="12" x2="3" y2="12"/>
+        </svg>
+      );
+  }
+};
+
 const LoginPage: React.FC = () => {
  const { t } = useTranslation();
  const [username, setUsername] = useState('');
@@ -36,6 +75,7 @@ const LoginPage: React.FC = () => {
  const [error, setError] = useState<string | null>(null);
  const [loading, setLoading] = useState(false);
  const [showDefaultPasswordWarning, setShowDefaultPasswordWarning] = useState(false);
+  const [ssoConfig, setSsoConfig] = useState<OAuthSsoConfig | null>(null);
  const { login } = useAuth();
  const location = useLocation();
  const navigate = useNavigate();
@@ -44,6 +84,25 @@ const LoginPage: React.FC = () => {
    return sanitizeReturnUrl(params.get('returnUrl'));
  }, [location.search]);

+  // Check for OAuth error in URL params
+  useEffect(() => {
+    const params = new URLSearchParams(location.search);
+    const oauthError = params.get('error');
+    const oauthMessage = params.get('message');
+    if (oauthError === 'oauth_failed' && oauthMessage) {
+      setError(oauthMessage);
+    }
+  }, [location.search]);
+
+  // Load OAuth SSO configuration
+  useEffect(() => {
+    const loadSsoConfig = async () => {
+      const config = await getOAuthSsoConfig();
+      setSsoConfig(config);
+    };
+    loadSsoConfig();
+  }, []);
+
  const isServerUnavailableError = useCallback((message?: string) => {
    if (!message) return false;
    const normalized = message.toLowerCase();
@@ -137,11 +196,18 @@ const LoginPage: React.FC = () => {
    }
  };

+  const handleSsoLogin = (provider: OAuthSsoProvider) => {
+    initiateOAuthSsoLogin(provider.id, returnUrl || undefined);
+  };
+
  const handleCloseWarning = () => {
    setShowDefaultPasswordWarning(false);
    redirectAfterLogin();
  };

+  const showLocalAuth = !ssoConfig?.enabled || ssoConfig.localAuthAllowed;
+  const showSsoProviders = ssoConfig?.enabled && ssoConfig.providers.length > 0;
+
  return (
    <div className="relative min-h-screen w-full overflow-hidden bg-gray-50 dark:bg-gray-950">
      {/* Top-right controls */}
@@ -193,6 +259,40 @@ const LoginPage: React.FC = () => {
          <div className="login-card relative w-full rounded-2xl border border-white/10 bg-white/60 p-8 shadow-xl backdrop-blur-md transition dark:border-white/10 dark:bg-gray-900/60">
            <div className="absolute -top-24 right-12 h-40 w-40 -translate-y-6 rounded-full bg-indigo-500/30 blur-3xl" />
            <div className="absolute -bottom-24 -left-12 h-40 w-40 translate-y-6 rounded-full bg-cyan-500/20 blur-3xl" />
+            
+            {/* SSO Providers */}
+            {showSsoProviders && (
+              <div className="mt-4 space-y-3">
+                {ssoConfig.providers.map((provider) => (
+                  <button
+                    key={provider.id}
+                    type="button"
+                    onClick={() => handleSsoLogin(provider)}
+                    className="group relative flex w-full items-center justify-center gap-3 rounded-md border border-gray-300/60 bg-white/80 px-4 py-3 text-sm font-medium text-gray-700 shadow-sm transition-all hover:bg-gray-50 hover:shadow focus:outline-none focus:ring-2 focus:ring-indigo-500 focus:ring-offset-2 dark:border-gray-600/60 dark:bg-gray-800/80 dark:text-gray-200 dark:hover:bg-gray-700/80"
+                  >
+                    <ProviderIcon type={provider.icon || provider.type} />
+                    <span>{provider.buttonText || t('oauthSso.signInWith', { provider: provider.name })}</span>
+                  </button>
+                ))}
+              </div>
+            )}
+
+            {/* Divider between SSO and local auth */}
+            {showSsoProviders && showLocalAuth && (
+              <div className="relative my-6">
+                <div className="absolute inset-0 flex items-center">
+                  <div className="w-full border-t border-gray-300/60 dark:border-gray-600/60" />
+                </div>
+                <div className="relative flex justify-center text-sm">
+                  <span className="bg-white/60 px-4 text-gray-500 dark:bg-gray-900/60 dark:text-gray-400">
+                    {t('oauthSso.orContinueWith')}
+                  </span>
+                </div>
+              </div>
+            )}
+
+            {/* Local auth form */}
+            {showLocalAuth && (
              <form className="mt-4 space-y-4" onSubmit={handleSubmit}>
                <div className="space-y-4">
                  <div>
@@ -245,6 +345,14 @@ const LoginPage: React.FC = () => {
                  </button>
                </div>
              </form>
+            )}
+
+            {/* Error display for SSO-only mode */}
+            {!showLocalAuth && error && (
+              <div className="mt-4 error-box rounded border border-red-500/20 bg-red-500/10 p-2 text-center text-sm text-red-600 dark:text-red-400">
+                {error}
+              </div>
+            )}
          </div>
        </div>
      </div>
--- a/frontend/src/pages/OAuthCallbackPage.tsx
+++ b/frontend/src/pages/OAuthCallbackPage.tsx
@@ -0,0 +1,42 @@
+import React, { useEffect } from 'react';
+import { useNavigate, useSearchParams } from 'react-router-dom';
+import { setToken } from '../services/authService';
+
+/**
+ * OAuth Callback Page
+ * 
+ * This page handles the callback from OAuth SSO providers.
+ * It receives the JWT token as a query parameter, stores it, and redirects to the app.
+ */
+const OAuthCallbackPage: React.FC = () => {
+  const navigate = useNavigate();
+  const [searchParams] = useSearchParams();
+
+  useEffect(() => {
+    const token = searchParams.get('token');
+    const returnUrl = searchParams.get('returnUrl') || '/';
+
+    if (token) {
+      // Store the token
+      setToken(token);
+      
+      // Redirect to the return URL
+      navigate(returnUrl, { replace: true });
+    } else {
+      // No token - redirect to login with error
+      navigate('/login?error=oauth_failed&message=No+token+received', { replace: true });
+    }
+  }, [searchParams, navigate]);
+
+  // Show loading state while processing
+  return (
+    <div className="min-h-screen flex items-center justify-center bg-gray-50 dark:bg-gray-950">
+      <div className="text-center">
+        <div className="animate-spin rounded-full h-12 w-12 border-t-2 border-b-2 border-indigo-500 mx-auto"></div>
+        <p className="mt-4 text-gray-600 dark:text-gray-400">Completing authentication...</p>
+      </div>
+    </div>
+  );
+};
+
+export default OAuthCallbackPage;
--- a/frontend/src/services/authService.ts
+++ b/frontend/src/services/authService.ts
@@ -3,6 +3,7 @@ import {
  LoginCredentials,
  RegisterCredentials,
  ChangePasswordCredentials,
+  OAuthSsoConfig,
 } from '../types';
 import { apiPost, apiGet } from '../utils/fetchInterceptor';
 import { getToken, setToken, removeToken } from '../utils/interceptors';
@@ -105,6 +106,30 @@ export const changePassword = async (
  }
 };

+// Get OAuth SSO configuration
+export const getOAuthSsoConfig = async (): Promise<OAuthSsoConfig | null> => {
+  try {
+    const response = await apiGet<{ success: boolean; data: OAuthSsoConfig }>('/auth/sso/config');
+    if (response.success && response.data) {
+      return response.data;
+    }
+    return null;
+  } catch (error) {
+    console.error('Get OAuth SSO config error:', error);
+    return null;
+  }
+};
+
+// Initiate OAuth SSO login (redirects to provider)
+export const initiateOAuthSsoLogin = (providerId: string, returnUrl?: string): void => {
+  const basePath = import.meta.env.VITE_BASE_PATH || '';
+  let url = `${basePath}/api/auth/sso/${providerId}`;
+  if (returnUrl) {
+    url += `?returnUrl=${encodeURIComponent(returnUrl)}`;
+  }
+  window.location.href = url;
+};
+
 // Logout user
 export const logout = (): void => {
  removeToken();
--- a/frontend/src/types/index.ts
+++ b/frontend/src/types/index.ts
@@ -381,6 +381,21 @@ export interface AuthResponse {
  isUsingDefaultPassword?: boolean;
 }

+// OAuth SSO types
+export interface OAuthSsoProvider {
+  id: string;
+  name: string;
+  type: string;
+  icon?: string;
+  buttonText?: string;
+}
+
+export interface OAuthSsoConfig {
+  enabled: boolean;
+  providers: OAuthSsoProvider[];
+  localAuthAllowed: boolean;
+}
+
 // Official Registry types (from registry.modelcontextprotocol.io)
 export interface RegistryVariable {
  choices?: string[];
--- a/locales/en.json
+++ b/locales/en.json
@@ -840,5 +840,25 @@
    "internalError": "Internal Error",
    "internalErrorMessage": "An unexpected error occurred while processing the OAuth callback.",
    "closeWindow": "Close Window"
+  },
+  "oauthSso": {
+    "errors": {
+      "providerIdRequired": "Provider ID is required",
+      "providerNotFound": "OAuth provider not found",
+      "missingState": "Missing OAuth state parameter",
+      "missingCode": "Missing authorization code",
+      "invalidState": "Invalid or expired OAuth state",
+      "authFailed": "OAuth authentication failed",
+      "userNotProvisioned": "User not found and auto-provisioning is disabled"
+    },
+    "signInWith": "Sign in with {{provider}}",
+    "orContinueWith": "Or continue with",
+    "continueWithProvider": "Continue with {{provider}}",
+    "loginWithSso": "Login with SSO",
+    "providers": {
+      "google": "Google",
+      "microsoft": "Microsoft",
+      "github": "GitHub"
+    }
  }
 }
--- a/locales/zh.json
+++ b/locales/zh.json
@@ -842,5 +842,25 @@
    "internalError": "内部错误",
    "internalErrorMessage": "处理 OAuth 回调时发生意外错误。",
    "closeWindow": "关闭窗口"
+  },
+  "oauthSso": {
+    "errors": {
+      "providerIdRequired": "需要提供身份验证提供商 ID",
+      "providerNotFound": "未找到 OAuth 身份验证提供商",
+      "missingState": "缺少 OAuth 状态参数",
+      "missingCode": "缺少授权码",
+      "invalidState": "OAuth 状态无效或已过期",
+      "authFailed": "OAuth 身份验证失败",
+      "userNotProvisioned": "用户未找到且自动创建用户已禁用"
+    },
+    "signInWith": "使用 {{provider}} 登录",
+    "orContinueWith": "或使用以下方式继续",
+    "continueWithProvider": "使用 {{provider}} 继续",
+    "loginWithSso": "使用 SSO 登录",
+    "providers": {
+      "google": "Google",
+      "microsoft": "Microsoft",
+      "github": "GitHub"
+    }
  }
 }
--- a/src/controllers/oauthSsoController.ts
+++ b/src/controllers/oauthSsoController.ts
@@ -0,0 +1,245 @@
+/**
+ * OAuth SSO Controller
+ *
+ * Handles OAuth SSO authentication endpoints.
+ */
+
+import { Request, Response } from 'express';
+import jwt from 'jsonwebtoken';
+import {
+  generateAuthorizationUrl,
+  handleCallback,
+  getPublicProviderInfo,
+  isLocalAuthAllowed,
+  isOAuthSsoEnabled,
+  getOAuthSsoConfig as getSsoConfigFromService,
+} from '../services/oauthSsoService.js';
+import { JWT_SECRET } from '../config/jwt.js';
+import config from '../config/index.js';
+
+const TOKEN_EXPIRY = '24h';
+
+/**
+ * Get the base URL for OAuth callbacks
+ * Uses configured callbackBaseUrl if available, otherwise derives from request
+ * This approach is more secure than blindly trusting forwarded headers
+ */
+async function getCallbackBaseUrl(req: Request): Promise<string> {
+  // First, check if a callback base URL is configured (most secure option)
+  const ssoConfig = await getSsoConfigFromService();
+  if (ssoConfig?.callbackBaseUrl) {
+    return ssoConfig.callbackBaseUrl;
+  }
+
+  // Fall back to deriving from request (less secure, but works in simpler setups)
+  // Only trust forwarded headers if app is configured to trust proxy
+  if (req.app.get('trust proxy') && req.headers['x-forwarded-proto'] && req.headers['x-forwarded-host']) {
+    const proto = Array.isArray(req.headers['x-forwarded-proto'])
+      ? req.headers['x-forwarded-proto'][0]
+      : req.headers['x-forwarded-proto'];
+    const host = Array.isArray(req.headers['x-forwarded-host'])
+      ? req.headers['x-forwarded-host'][0]
+      : req.headers['x-forwarded-host'];
+    return `${proto}://${host}`;
+  }
+
+  return `${req.protocol}://${req.get('host')}`;
+}
+
+/**
+ * Get OAuth SSO configuration for frontend
+ * Returns enabled providers and whether local auth is allowed
+ */
+export const getOAuthSsoConfig = async (req: Request, res: Response): Promise<void> => {
+  try {
+    const enabled = await isOAuthSsoEnabled();
+    const providers = await getPublicProviderInfo();
+    const localAuthAllowed = await isLocalAuthAllowed();
+
+    res.json({
+      success: true,
+      data: {
+        enabled,
+        providers,
+        localAuthAllowed,
+      },
+    });
+  } catch (error) {
+    console.error('Error getting OAuth SSO config:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to get OAuth SSO configuration',
+    });
+  }
+};
+
+/**
+ * Initiate OAuth SSO login
+ * Redirects user to the OAuth provider's authorization page
+ */
+export const initiateOAuthLogin = async (req: Request, res: Response): Promise<void> => {
+  const t = (req as any).t || ((key: string) => key);
+
+  try {
+    const { providerId } = req.params;
+    const { returnUrl } = req.query;
+
+    if (!providerId) {
+      res.status(400).json({
+        success: false,
+        message: t('oauthSso.errors.providerIdRequired'),
+      });
+      return;
+    }
+
+    // Build callback URL
+    // Note: Use configured callback base URL from oauthSso config if available
+    // This avoids relying on potentially untrusted forwarded headers
+    const baseUrl = await getCallbackBaseUrl(req);
+
+    const callbackUrl = `${baseUrl}${config.basePath}/api/auth/sso/${providerId}/callback`;
+
+    // Generate authorization URL
+    const { url } = await generateAuthorizationUrl(
+      providerId,
+      callbackUrl,
+      typeof returnUrl === 'string' ? returnUrl : undefined,
+    );
+
+    // Redirect to OAuth provider
+    res.redirect(url);
+  } catch (error) {
+    console.error('Error initiating OAuth login:', error);
+    const errorMessage = error instanceof Error ? error.message : 'Failed to initiate OAuth login';
+    res.status(500).json({
+      success: false,
+      message: errorMessage,
+    });
+  }
+};
+
+/**
+ * Handle OAuth callback from provider
+ * Exchanges code for tokens and creates/updates user
+ */
+export const handleOAuthCallback = async (req: Request, res: Response): Promise<void> => {
+  const t = (req as any).t || ((key: string) => key);
+
+  try {
+    const { providerId } = req.params;
+    const { code, state, error, error_description } = req.query;
+
+    // Handle OAuth errors
+    if (error) {
+      console.error(`OAuth error from provider ${providerId}:`, error, error_description);
+      const errorUrl = buildErrorRedirectUrl(String(error_description || error), req);
+      return res.redirect(errorUrl);
+    }
+
+    // Validate required parameters
+    if (!state) {
+      const errorUrl = buildErrorRedirectUrl(t('oauthSso.errors.missingState'), req);
+      return res.redirect(errorUrl);
+    }
+
+    if (!code) {
+      const errorUrl = buildErrorRedirectUrl(t('oauthSso.errors.missingCode'), req);
+      return res.redirect(errorUrl);
+    }
+
+    // Build callback URL (same as used in initiate)
+    const baseUrl = await getCallbackBaseUrl(req);
+
+    const callbackUrl = `${baseUrl}${config.basePath}/api/auth/sso/${providerId}/callback`;
+
+    // Full current URL with query params
+    const currentUrl = `${callbackUrl}?${new URLSearchParams(req.query as Record<string, string>).toString()}`;
+
+    // Exchange code for tokens and get user
+    const { user, returnUrl } = await handleCallback(
+      callbackUrl,
+      currentUrl,
+      String(state),
+    );
+
+    // Generate JWT token
+    const payload = {
+      user: {
+        username: user.username,
+        isAdmin: user.isAdmin || false,
+      },
+    };
+
+    const token = jwt.sign(payload, JWT_SECRET, { expiresIn: TOKEN_EXPIRY });
+
+    // Redirect to frontend with token
+    const redirectUrl = buildSuccessRedirectUrl(token, returnUrl, req);
+    res.redirect(redirectUrl);
+  } catch (error) {
+    console.error('Error handling OAuth callback:', error);
+    const errorMessage =
+      error instanceof Error ? error.message : 'Authentication failed';
+    const errorUrl = buildErrorRedirectUrl(errorMessage, req);
+    res.redirect(errorUrl);
+  }
+};
+
+/**
+ * Get list of available OAuth providers
+ */
+export const listOAuthProviders = async (req: Request, res: Response): Promise<void> => {
+  try {
+    const providers = await getPublicProviderInfo();
+    res.json({
+      success: true,
+      data: providers,
+    });
+  } catch (error) {
+    console.error('Error listing OAuth providers:', error);
+    res.status(500).json({
+      success: false,
+      message: 'Failed to list OAuth providers',
+    });
+  }
+};
+
+/**
+ * Build redirect URL for successful authentication
+ */
+function buildSuccessRedirectUrl(token: string, returnUrl: string | undefined, req: Request): string {
+  const baseUrl = getBaseUrl(req);
+  const targetPath = returnUrl || '/';
+  
+  // Use a special OAuth callback page that stores the token
+  const callbackPath = `${config.basePath}/oauth-callback`;
+  const params = new URLSearchParams({
+    token,
+    returnUrl: targetPath,
+  });
+
+  return `${baseUrl}${callbackPath}?${params.toString()}`;
+}
+
+/**
+ * Build redirect URL for authentication errors
+ */
+function buildErrorRedirectUrl(error: string, req: Request): string {
+  const baseUrl = getBaseUrl(req);
+  const loginPath = `${config.basePath}/login`;
+  const params = new URLSearchParams({
+    error: 'oauth_failed',
+    message: error,
+  });
+
+  return `${baseUrl}${loginPath}?${params.toString()}`;
+}
+
+/**
+ * Get base URL from request
+ */
+function getBaseUrl(req: Request): string {
+  if (req.headers['x-forwarded-proto'] && req.headers['x-forwarded-host']) {
+    return `${req.headers['x-forwarded-proto']}://${req.headers['x-forwarded-host']}`;
+  }
+  return `${req.protocol}://${req.get('host')}`;
+}
--- a/src/dao/DaoFactory.ts
+++ b/src/dao/DaoFactory.ts
@@ -6,7 +6,6 @@ import { UserConfigDao, UserConfigDaoImpl } from './UserConfigDao.js';
 import { OAuthClientDao, OAuthClientDaoImpl } from './OAuthClientDao.js';
 import { OAuthTokenDao, OAuthTokenDaoImpl } from './OAuthTokenDao.js';
 import { BearerKeyDao, BearerKeyDaoImpl } from './BearerKeyDao.js';
-import { ToolCallActivityDao } from './ToolCallActivityDao.js';

 /**
 * DAO Factory interface for creating DAO instances
@@ -20,7 +19,6 @@ export interface DaoFactory {
  getOAuthClientDao(): OAuthClientDao;
  getOAuthTokenDao(): OAuthTokenDao;
  getBearerKeyDao(): BearerKeyDao;
-  getToolCallActivityDao(): ToolCallActivityDao | null; // Only available in DB mode
 }

 /**
@@ -108,11 +106,6 @@ export class JsonFileDaoFactory implements DaoFactory {
    return this.bearerKeyDao;
  }

-  getToolCallActivityDao(): ToolCallActivityDao | null {
-    // Tool call activity is only available in DB mode
-    return null;
-  }
-
  /**
   * Reset all cached DAO instances (useful for testing)
   */
@@ -201,14 +194,3 @@ export function getOAuthTokenDao(): OAuthTokenDao {
 export function getBearerKeyDao(): BearerKeyDao {
  return getDaoFactory().getBearerKeyDao();
 }
-
-export function getToolCallActivityDao(): ToolCallActivityDao | null {
-  return getDaoFactory().getToolCallActivityDao();
-}
-
-/**
- * Check if the application is using database mode
- */
-export function isUsingDatabase(): boolean {
-  return getDaoFactory().getToolCallActivityDao() !== null;
-}
--- a/src/dao/DatabaseDaoFactory.ts
+++ b/src/dao/DatabaseDaoFactory.ts
@@ -8,7 +8,6 @@ import {
  OAuthClientDao,
  OAuthTokenDao,
  BearerKeyDao,
-  ToolCallActivityDao,
 } from './index.js';
 import { UserDaoDbImpl } from './UserDaoDbImpl.js';
 import { ServerDaoDbImpl } from './ServerDaoDbImpl.js';
@@ -18,7 +17,6 @@ import { UserConfigDaoDbImpl } from './UserConfigDaoDbImpl.js';
 import { OAuthClientDaoDbImpl } from './OAuthClientDaoDbImpl.js';
 import { OAuthTokenDaoDbImpl } from './OAuthTokenDaoDbImpl.js';
 import { BearerKeyDaoDbImpl } from './BearerKeyDaoDbImpl.js';
-import { ToolCallActivityDaoDbImpl } from './ToolCallActivityDao.js';

 /**
 * Database-backed DAO factory implementation
@@ -34,7 +32,6 @@ export class DatabaseDaoFactory implements DaoFactory {
  private oauthClientDao: OAuthClientDao | null = null;
  private oauthTokenDao: OAuthTokenDao | null = null;
  private bearerKeyDao: BearerKeyDao | null = null;
-  private toolCallActivityDao: ToolCallActivityDao | null = null;

  /**
   * Get singleton instance
@@ -106,13 +103,6 @@ export class DatabaseDaoFactory implements DaoFactory {
    return this.bearerKeyDao!;
  }

-  getToolCallActivityDao(): ToolCallActivityDao | null {
-    if (!this.toolCallActivityDao) {
-      this.toolCallActivityDao = new ToolCallActivityDaoDbImpl();
-    }
-    return this.toolCallActivityDao;
-  }
-
  /**
   * Reset all cached DAO instances (useful for testing)
   */
@@ -125,6 +115,5 @@ export class DatabaseDaoFactory implements DaoFactory {
    this.oauthClientDao = null;
    this.oauthTokenDao = null;
    this.bearerKeyDao = null;
-    this.toolCallActivityDao = null;
  }
 }
--- a/src/dao/SystemConfigDaoDbImpl.ts
+++ b/src/dao/SystemConfigDaoDbImpl.ts
@@ -22,6 +22,7 @@ export class SystemConfigDaoDbImpl implements SystemConfigDao {
      nameSeparator: config.nameSeparator,
      oauth: config.oauth as any,
      oauthServer: config.oauthServer as any,
+      oauthSso: config.oauthSso as any,
      enableSessionRebuild: config.enableSessionRebuild,
    };
  }
@@ -36,6 +37,7 @@ export class SystemConfigDaoDbImpl implements SystemConfigDao {
      nameSeparator: updated.nameSeparator,
      oauth: updated.oauth as any,
      oauthServer: updated.oauthServer as any,
+      oauthSso: updated.oauthSso as any,
      enableSessionRebuild: updated.enableSessionRebuild,
    };
  }
@@ -50,6 +52,7 @@ export class SystemConfigDaoDbImpl implements SystemConfigDao {
      nameSeparator: config.nameSeparator,
      oauth: config.oauth as any,
      oauthServer: config.oauthServer as any,
+      oauthSso: config.oauthSso as any,
      enableSessionRebuild: config.enableSessionRebuild,
    };
  }
--- a/src/dao/ToolCallActivityDao.ts
+++ b/src/dao/ToolCallActivityDao.ts
@@ -1,186 +0,0 @@
-import {
-  IToolCallActivity,
-  IToolCallActivitySearchParams,
-  IToolCallActivityPage,
-  IToolCallActivityStats,
-} from '../types/index.js';
-import { ToolCallActivityRepository } from '../db/repositories/ToolCallActivityRepository.js';
-
-/**
- * Tool Call Activity DAO interface (DB mode only)
- */
-export interface ToolCallActivityDao {
-  /**
-   * Create a new tool call activity
-   */
-  create(activity: Omit<IToolCallActivity, 'id' | 'createdAt'>): Promise<IToolCallActivity>;
-
-  /**
-   * Find activity by ID
-   */
-  findById(id: string): Promise<IToolCallActivity | null>;
-
-  /**
-   * Update an existing activity
-   */
-  update(id: string, updates: Partial<IToolCallActivity>): Promise<IToolCallActivity | null>;
-
-  /**
-   * Delete an activity
-   */
-  delete(id: string): Promise<boolean>;
-
-  /**
-   * Find activities with pagination and filtering
-   */
-  findWithPagination(
-    page: number,
-    pageSize: number,
-    params?: IToolCallActivitySearchParams,
-  ): Promise<IToolCallActivityPage>;
-
-  /**
-   * Get recent activities
-   */
-  findRecent(limit: number): Promise<IToolCallActivity[]>;
-
-  /**
-   * Get activity statistics
-   */
-  getStats(): Promise<IToolCallActivityStats>;
-
-  /**
-   * Delete old activities (cleanup)
-   */
-  deleteOlderThan(date: Date): Promise<number>;
-
-  /**
-   * Count total activities
-   */
-  count(): Promise<number>;
-}
-
-/**
- * Database-backed implementation of ToolCallActivityDao
- */
-export class ToolCallActivityDaoDbImpl implements ToolCallActivityDao {
-  private repository: ToolCallActivityRepository;
-
-  constructor() {
-    this.repository = new ToolCallActivityRepository();
-  }
-
-  async create(activity: Omit<IToolCallActivity, 'id' | 'createdAt'>): Promise<IToolCallActivity> {
-    const created = await this.repository.create({
-      serverName: activity.serverName,
-      toolName: activity.toolName,
-      keyId: activity.keyId,
-      keyName: activity.keyName,
-      status: activity.status,
-      request: activity.request,
-      response: activity.response,
-      errorMessage: activity.errorMessage,
-      durationMs: activity.durationMs,
-      clientIp: activity.clientIp,
-      sessionId: activity.sessionId,
-      groupName: activity.groupName,
-    });
-    return this.mapToInterface(created);
-  }
-
-  async findById(id: string): Promise<IToolCallActivity | null> {
-    const activity = await this.repository.findById(id);
-    return activity ? this.mapToInterface(activity) : null;
-  }
-
-  async update(
-    id: string,
-    updates: Partial<IToolCallActivity>,
-  ): Promise<IToolCallActivity | null> {
-    const updated = await this.repository.update(id, {
-      serverName: updates.serverName,
-      toolName: updates.toolName,
-      keyId: updates.keyId,
-      keyName: updates.keyName,
-      status: updates.status,
-      request: updates.request,
-      response: updates.response,
-      errorMessage: updates.errorMessage,
-      durationMs: updates.durationMs,
-      clientIp: updates.clientIp,
-      sessionId: updates.sessionId,
-      groupName: updates.groupName,
-    });
-    return updated ? this.mapToInterface(updated) : null;
-  }
-
-  async delete(id: string): Promise<boolean> {
-    return await this.repository.delete(id);
-  }
-
-  async findWithPagination(
-    page: number = 1,
-    pageSize: number = 20,
-    params: IToolCallActivitySearchParams = {},
-  ): Promise<IToolCallActivityPage> {
-    const result = await this.repository.findWithPagination(page, pageSize, params);
-    return {
-      items: result.items.map((item) => this.mapToInterface(item)),
-      total: result.total,
-      page: result.page,
-      pageSize: result.pageSize,
-      totalPages: result.totalPages,
-    };
-  }
-
-  async findRecent(limit: number = 10): Promise<IToolCallActivity[]> {
-    const activities = await this.repository.findRecent(limit);
-    return activities.map((activity) => this.mapToInterface(activity));
-  }
-
-  async getStats(): Promise<IToolCallActivityStats> {
-    return await this.repository.getStats();
-  }
-
-  async deleteOlderThan(date: Date): Promise<number> {
-    return await this.repository.deleteOlderThan(date);
-  }
-
-  async count(): Promise<number> {
-    return await this.repository.count();
-  }
-
-  private mapToInterface(activity: {
-    id: string;
-    serverName: string;
-    toolName: string;
-    keyId?: string;
-    keyName?: string;
-    status: 'pending' | 'success' | 'error';
-    request?: string;
-    response?: string;
-    errorMessage?: string;
-    durationMs?: number;
-    clientIp?: string;
-    sessionId?: string;
-    groupName?: string;
-    createdAt: Date;
-  }): IToolCallActivity {
-    return {
-      id: activity.id,
-      serverName: activity.serverName,
-      toolName: activity.toolName,
-      keyId: activity.keyId,
-      keyName: activity.keyName,
-      status: activity.status,
-      request: activity.request,
-      response: activity.response,
-      errorMessage: activity.errorMessage,
-      durationMs: activity.durationMs,
-      clientIp: activity.clientIp,
-      sessionId: activity.sessionId,
-      groupName: activity.groupName,
-      createdAt: activity.createdAt,
-    };
-  }
-}
--- a/src/dao/UserDaoDbImpl.ts
+++ b/src/dao/UserDaoDbImpl.ts
@@ -13,23 +13,28 @@ export class UserDaoDbImpl implements UserDao {
    this.repository = new UserRepository();
  }

-  async findAll(): Promise<IUser[]> {
-    const users = await this.repository.findAll();
-    return users.map((u) => ({
+  private mapToIUser(u: any): IUser {
+    return {
      username: u.username,
      password: u.password,
      isAdmin: u.isAdmin,
-    }));
+      oauthProvider: u.oauthProvider,
+      oauthSubject: u.oauthSubject,
+      email: u.email,
+      displayName: u.displayName,
+      avatarUrl: u.avatarUrl,
+    };
+  }
+
+  async findAll(): Promise<IUser[]> {
+    const users = await this.repository.findAll();
+    return users.map(this.mapToIUser);
  }

  async findById(username: string): Promise<IUser | null> {
    const user = await this.repository.findByUsername(username);
    if (!user) return null;
-    return {
-      username: user.username,
-      password: user.password,
-      isAdmin: user.isAdmin,
-    };
+    return this.mapToIUser(user);
  }

  async findByUsername(username: string): Promise<IUser | null> {
@@ -41,12 +46,13 @@ export class UserDaoDbImpl implements UserDao {
      username: entity.username,
      password: entity.password,
      isAdmin: entity.isAdmin || false,
+      oauthProvider: entity.oauthProvider,
+      oauthSubject: entity.oauthSubject,
+      email: entity.email,
+      displayName: entity.displayName,
+      avatarUrl: entity.avatarUrl,
    });
-    return {
-      username: user.username,
-      password: user.password,
-      isAdmin: user.isAdmin,
-    };
+    return this.mapToIUser(user);
  }

  async createWithHashedPassword(
@@ -62,13 +68,14 @@ export class UserDaoDbImpl implements UserDao {
    const user = await this.repository.update(username, {
      password: entity.password,
      isAdmin: entity.isAdmin,
+      oauthProvider: entity.oauthProvider,
+      oauthSubject: entity.oauthSubject,
+      email: entity.email,
+      displayName: entity.displayName,
+      avatarUrl: entity.avatarUrl,
    });
    if (!user) return null;
-    return {
-      username: user.username,
-      password: user.password,
-      isAdmin: user.isAdmin,
-    };
+    return this.mapToIUser(user);
  }

  async delete(username: string): Promise<boolean> {
@@ -99,10 +106,6 @@ export class UserDaoDbImpl implements UserDao {

  async findAdmins(): Promise<IUser[]> {
    const users = await this.repository.findAdmins();
-    return users.map((u) => ({
-      username: u.username,
-      password: u.password,
-      isAdmin: u.isAdmin,
-    }));
+    return users.map(this.mapToIUser);
  }
 }
--- a/src/dao/index.ts
+++ b/src/dao/index.ts
@@ -9,7 +9,6 @@ export * from './UserConfigDao.js';
 export * from './OAuthClientDao.js';
 export * from './OAuthTokenDao.js';
 export * from './BearerKeyDao.js';
-export * from './ToolCallActivityDao.js';

 // Export database implementations
 export * from './UserDaoDbImpl.js';
--- a/src/db/entities/SystemConfig.ts
+++ b/src/db/entities/SystemConfig.ts
@@ -30,6 +30,9 @@ export class SystemConfig {
  @Column({ type: 'simple-json', nullable: true })
  oauthServer?: Record<string, any>;

+  @Column({ name: 'oauth_sso', type: 'simple-json', nullable: true })
+  oauthSso?: Record<string, any>;
+
  @Column({ type: 'boolean', nullable: true })
  enableSessionRebuild?: boolean;

--- a/src/db/entities/ToolCallActivity.ts
+++ b/src/db/entities/ToolCallActivity.ts
@@ -1,62 +0,0 @@
-import {
-  Entity,
-  Column,
-  PrimaryGeneratedColumn,
-  CreateDateColumn,
-  Index,
-} from 'typeorm';
-
-/**
- * Tool call activity entity for logging tool invocations (DB mode only)
- */
-@Entity({ name: 'tool_call_activities' })
-export class ToolCallActivity {
-  @PrimaryGeneratedColumn('uuid')
-  id: string;
-
-  @Index()
-  @Column({ type: 'varchar', length: 255, name: 'server_name' })
-  serverName: string;
-
-  @Index()
-  @Column({ type: 'varchar', length: 255, name: 'tool_name' })
-  toolName: string;
-
-  @Index()
-  @Column({ type: 'varchar', length: 255, name: 'key_id', nullable: true })
-  keyId?: string;
-
-  @Column({ type: 'varchar', length: 255, name: 'key_name', nullable: true })
-  keyName?: string;
-
-  @Index()
-  @Column({ type: 'varchar', length: 50, default: 'pending' })
-  status: 'pending' | 'success' | 'error';
-
-  @Column({ type: 'text', nullable: true })
-  request?: string;
-
-  @Column({ type: 'text', nullable: true })
-  response?: string;
-
-  @Column({ type: 'text', name: 'error_message', nullable: true })
-  errorMessage?: string;
-
-  @Column({ type: 'int', name: 'duration_ms', nullable: true })
-  durationMs?: number;
-
-  @Column({ type: 'varchar', length: 100, name: 'client_ip', nullable: true })
-  clientIp?: string;
-
-  @Column({ type: 'varchar', length: 255, name: 'session_id', nullable: true })
-  sessionId?: string;
-
-  @Column({ type: 'varchar', length: 255, name: 'group_name', nullable: true })
-  groupName?: string;
-
-  @Index()
-  @CreateDateColumn({ name: 'created_at', type: 'timestamp' })
-  createdAt: Date;
-}
-
-export default ToolCallActivity;
--- a/src/db/entities/User.ts
+++ b/src/db/entities/User.ts
@@ -23,6 +23,22 @@ export class User {
  @Column({ type: 'boolean', default: false })
  isAdmin: boolean;

+  // OAuth SSO fields
+  @Column({ name: 'oauth_provider', type: 'varchar', length: 100, nullable: true })
+  oauthProvider?: string;
+
+  @Column({ name: 'oauth_subject', type: 'varchar', length: 255, nullable: true })
+  oauthSubject?: string;
+
+  @Column({ type: 'varchar', length: 255, nullable: true })
+  email?: string;
+
+  @Column({ name: 'display_name', type: 'varchar', length: 255, nullable: true })
+  displayName?: string;
+
+  @Column({ name: 'avatar_url', type: 'text', nullable: true })
+  avatarUrl?: string;
+
  @CreateDateColumn({ name: 'created_at', type: 'timestamp' })
  createdAt: Date;

--- a/src/db/entities/index.ts
+++ b/src/db/entities/index.ts
@@ -7,7 +7,6 @@ import UserConfig from './UserConfig.js';
 import OAuthClient from './OAuthClient.js';
 import OAuthToken from './OAuthToken.js';
 import BearerKey from './BearerKey.js';
-import ToolCallActivity from './ToolCallActivity.js';

 // Export all entities
 export default [
@@ -20,7 +19,6 @@ export default [
  OAuthClient,
  OAuthToken,
  BearerKey,
-  ToolCallActivity,
 ];

 // Export individual entities for direct use
@@ -34,5 +32,4 @@ export {
  OAuthClient,
  OAuthToken,
  BearerKey,
-  ToolCallActivity,
 };
--- a/src/db/repositories/ToolCallActivityRepository.ts
+++ b/src/db/repositories/ToolCallActivityRepository.ts
@@ -1,200 +0,0 @@
-import { Repository, FindOptionsWhere, ILike, Between } from 'typeorm';
-import { ToolCallActivity } from '../entities/ToolCallActivity.js';
-import { getAppDataSource } from '../connection.js';
-
-/**
- * Search parameters for filtering tool call activities
- */
-export interface ToolCallActivitySearchParams {
-  serverName?: string;
-  toolName?: string;
-  keyId?: string;
-  status?: 'pending' | 'success' | 'error';
-  groupName?: string;
-  startDate?: Date;
-  endDate?: Date;
-  searchQuery?: string;
-}
-
-/**
- * Pagination result for tool call activities
- */
-export interface ToolCallActivityPage {
-  items: ToolCallActivity[];
-  total: number;
-  page: number;
-  pageSize: number;
-  totalPages: number;
-}
-
-/**
- * Repository for ToolCallActivity entity
- */
-export class ToolCallActivityRepository {
-  private repository: Repository<ToolCallActivity>;
-
-  constructor() {
-    this.repository = getAppDataSource().getRepository(ToolCallActivity);
-  }
-
-  /**
-   * Create a new tool call activity
-   */
-  async create(
-    activity: Omit<ToolCallActivity, 'id' | 'createdAt'>,
-  ): Promise<ToolCallActivity> {
-    const newActivity = this.repository.create(activity);
-    return await this.repository.save(newActivity);
-  }
-
-  /**
-   * Find activity by ID
-   */
-  async findById(id: string): Promise<ToolCallActivity | null> {
-    return await this.repository.findOne({ where: { id } });
-  }
-
-  /**
-   * Update an existing activity
-   */
-  async update(
-    id: string,
-    updates: Partial<ToolCallActivity>,
-  ): Promise<ToolCallActivity | null> {
-    const activity = await this.findById(id);
-    if (!activity) {
-      return null;
-    }
-    const updated = this.repository.merge(activity, updates);
-    return await this.repository.save(updated);
-  }
-
-  /**
-   * Delete an activity
-   */
-  async delete(id: string): Promise<boolean> {
-    const result = await this.repository.delete({ id });
-    return (result.affected ?? 0) > 0;
-  }
-
-  /**
-   * Find activities with pagination and filtering
-   */
-  async findWithPagination(
-    page: number = 1,
-    pageSize: number = 20,
-    params: ToolCallActivitySearchParams = {},
-  ): Promise<ToolCallActivityPage> {
-    const where: FindOptionsWhere<ToolCallActivity>[] = [];
-    const baseWhere: FindOptionsWhere<ToolCallActivity> = {};
-
-    // Add filters
-    if (params.serverName) {
-      baseWhere.serverName = params.serverName;
-    }
-    if (params.toolName) {
-      baseWhere.toolName = params.toolName;
-    }
-    if (params.keyId) {
-      baseWhere.keyId = params.keyId;
-    }
-    if (params.status) {
-      baseWhere.status = params.status;
-    }
-    if (params.groupName) {
-      baseWhere.groupName = params.groupName;
-    }
-    if (params.startDate && params.endDate) {
-      baseWhere.createdAt = Between(params.startDate, params.endDate);
-    }
-
-    // Handle search query - search across multiple fields
-    if (params.searchQuery) {
-      const searchPattern = `%${params.searchQuery}%`;
-      where.push(
-        { ...baseWhere, serverName: ILike(searchPattern) },
-        { ...baseWhere, toolName: ILike(searchPattern) },
-        { ...baseWhere, keyName: ILike(searchPattern) },
-        { ...baseWhere, groupName: ILike(searchPattern) },
-      );
-    } else {
-      where.push(baseWhere);
-    }
-
-    const [items, total] = await this.repository.findAndCount({
-      where: where.length > 0 ? where : undefined,
-      order: { createdAt: 'DESC' },
-      skip: (page - 1) * pageSize,
-      take: pageSize,
-    });
-
-    return {
-      items,
-      total,
-      page,
-      pageSize,
-      totalPages: Math.ceil(total / pageSize),
-    };
-  }
-
-  /**
-   * Get recent activities
-   */
-  async findRecent(limit: number = 10): Promise<ToolCallActivity[]> {
-    return await this.repository.find({
-      order: { createdAt: 'DESC' },
-      take: limit,
-    });
-  }
-
-  /**
-   * Get activity statistics
-   */
-  async getStats(): Promise<{
-    total: number;
-    success: number;
-    error: number;
-    pending: number;
-    avgDurationMs: number;
-  }> {
-    const stats = await this.repository
-      .createQueryBuilder('activity')
-      .select([
-        'COUNT(*) as total',
-        'SUM(CASE WHEN status = \'success\' THEN 1 ELSE 0 END) as success',
-        'SUM(CASE WHEN status = \'error\' THEN 1 ELSE 0 END) as error',
-        'SUM(CASE WHEN status = \'pending\' THEN 1 ELSE 0 END) as pending',
-        'AVG(duration_ms) as avgDurationMs',
-      ])
-      .getRawOne();
-
-    return {
-      total: parseInt(stats?.total || '0', 10),
-      success: parseInt(stats?.success || '0', 10),
-      error: parseInt(stats?.error || '0', 10),
-      pending: parseInt(stats?.pending || '0', 10),
-      avgDurationMs: parseFloat(stats?.avgDurationMs || '0'),
-    };
-  }
-
-  /**
-   * Delete old activities (cleanup)
-   */
-  async deleteOlderThan(date: Date): Promise<number> {
-    const result = await this.repository
-      .createQueryBuilder()
-      .delete()
-      .where('created_at < :date', { date })
-      .execute();
-    return result.affected ?? 0;
-  }
-
-  /**
-   * Count total activities
-   */
-  async count(): Promise<number> {
-    return await this.repository.count();
-  }
-}
-
-export default ToolCallActivityRepository;
--- a/src/db/repositories/index.ts
+++ b/src/db/repositories/index.ts
@@ -7,7 +7,6 @@ import { UserConfigRepository } from './UserConfigRepository.js';
 import { OAuthClientRepository } from './OAuthClientRepository.js';
 import { OAuthTokenRepository } from './OAuthTokenRepository.js';
 import { BearerKeyRepository } from './BearerKeyRepository.js';
-import { ToolCallActivityRepository } from './ToolCallActivityRepository.js';

 // Export all repositories
 export {
@@ -20,5 +19,4 @@ export {
  OAuthClientRepository,
  OAuthTokenRepository,
  BearerKeyRepository,
-  ToolCallActivityRepository,
 };
--- a/src/routes/index.ts
+++ b/src/routes/index.ts
@@ -112,6 +112,12 @@ import {
  updateBearerKey,
  deleteBearerKey,
 } from '../controllers/bearerKeyController.js';
+import {
+  getOAuthSsoConfig,
+  initiateOAuthLogin,
+  handleOAuthCallback as handleOAuthSsoCallback,
+  listOAuthProviders,
+} from '../controllers/oauthSsoController.js';
 import { auth } from '../middlewares/auth.js';

 const router = express.Router();
@@ -273,6 +279,12 @@ export const initRoutes = (app: express.Application): void => {
    changePassword,
  );

+  // OAuth SSO routes (no auth required - these are for logging in)
+  router.get('/auth/sso/config', getOAuthSsoConfig);
+  router.get('/auth/sso/providers', listOAuthProviders);
+  router.get('/auth/sso/:providerId', initiateOAuthLogin);
+  router.get('/auth/sso/:providerId/callback', handleOAuthSsoCallback);
+
  // Runtime configuration endpoint (no auth required for frontend initialization)
  app.get(`${config.basePath}/config`, getRuntimeConfig);

--- a/src/services/oauthSsoService.ts
+++ b/src/services/oauthSsoService.ts
@@ -0,0 +1,546 @@
+/**
+ * OAuth SSO Service
+ *
+ * Handles OAuth 2.0 / OIDC SSO authentication for user login.
+ * Supports Google, Microsoft, GitHub, and custom OIDC providers.
+ */
+
+import * as client from 'openid-client';
+import crypto from 'crypto';
+import { getSystemConfigDao, getUserDao } from '../dao/index.js';
+import { IUser, OAuthSsoProviderConfig, OAuthSsoConfig } from '../types/index.js';
+
+// In-memory store for OAuth state (code verifier, state, etc.)
+// NOTE: This implementation uses in-memory storage which is suitable for single-instance deployments.
+// For multi-instance/scaled deployments, implement Redis or database-backed state storage
+// to ensure OAuth callbacks reach the correct instance where the state was stored.
+interface OAuthStateEntry {
+  codeVerifier: string;
+  providerId: string;
+  returnUrl?: string;
+  createdAt: number;
+}
+
+const stateStore = new Map<string, OAuthStateEntry>();
+const STATE_TTL_MS = 10 * 60 * 1000; // 10 minutes
+
+// Cleanup old state entries periodically
+let cleanupInterval: ReturnType<typeof setInterval> | null = null;
+
+function startStateCleanup(): void {
+  if (cleanupInterval) return;
+  cleanupInterval = setInterval(() => {
+    const now = Date.now();
+    for (const [state, entry] of stateStore.entries()) {
+      if (now - entry.createdAt > STATE_TTL_MS) {
+        stateStore.delete(state);
+      }
+    }
+  }, 60 * 1000); // Cleanup every minute
+}
+
+// Start cleanup on module load
+startStateCleanup();
+
+/**
+ * Stop the state cleanup interval (useful for tests and graceful shutdown)
+ */
+export function stopStateCleanup(): void {
+  if (cleanupInterval) {
+    clearInterval(cleanupInterval);
+    cleanupInterval = null;
+  }
+}
+
+// GitHub API response types for type safety
+interface GitHubUserResponse {
+  id: number;
+  login: string;
+  name?: string;
+  email?: string;
+  avatar_url?: string;
+}
+
+interface GitHubEmailResponse {
+  email: string;
+  primary: boolean;
+  verified: boolean;
+  visibility?: string;
+}
+
+// Provider configurations cache
+const providerConfigsCache = new Map<
+  string,
+  {
+    config: client.Configuration;
+    provider: OAuthSsoProviderConfig;
+  }
+>();
+
+/**
+ * Get OAuth SSO configuration from system config
+ */
+export async function getOAuthSsoConfig(): Promise<OAuthSsoConfig | undefined> {
+  const systemConfigDao = getSystemConfigDao();
+  const systemConfig = await systemConfigDao.get();
+  return systemConfig?.oauthSso;
+}
+
+/**
+ * Check if OAuth SSO is enabled
+ */
+export async function isOAuthSsoEnabled(): Promise<boolean> {
+  const config = await getOAuthSsoConfig();
+  return config?.enabled === true && (config.providers?.length ?? 0) > 0;
+}
+
+/**
+ * Get enabled OAuth SSO providers
+ */
+export async function getEnabledProviders(): Promise<OAuthSsoProviderConfig[]> {
+  const config = await getOAuthSsoConfig();
+  if (!config?.enabled || !config.providers) {
+    return [];
+  }
+  return config.providers.filter((p) => p.enabled !== false);
+}
+
+/**
+ * Get a specific provider by ID
+ */
+export async function getProviderById(providerId: string): Promise<OAuthSsoProviderConfig | undefined> {
+  const providers = await getEnabledProviders();
+  return providers.find((p) => p.id === providerId);
+}
+
+/**
+ * Get default scopes for a provider type
+ */
+function getDefaultScopes(type: OAuthSsoProviderConfig['type']): string[] {
+  switch (type) {
+    case 'google':
+      return ['openid', 'email', 'profile'];
+    case 'microsoft':
+      return ['openid', 'email', 'profile', 'User.Read'];
+    case 'github':
+      return ['read:user', 'user:email'];
+    case 'oidc':
+    default:
+      return ['openid', 'email', 'profile'];
+  }
+}
+
+/**
+ * Get provider discovery URL
+ */
+function getDiscoveryUrl(provider: OAuthSsoProviderConfig): string | undefined {
+  if (provider.issuerUrl) {
+    return provider.issuerUrl;
+  }
+
+  switch (provider.type) {
+    case 'google':
+      return 'https://accounts.google.com';
+    case 'microsoft':
+      // Using common endpoint for multi-tenant
+      return 'https://login.microsoftonline.com/common/v2.0';
+    case 'github':
+      // GitHub doesn't support OIDC discovery, we'll use explicit endpoints
+      return undefined;
+    default:
+      return undefined;
+  }
+}
+
+/**
+ * Get explicit OAuth endpoints for providers without OIDC discovery
+ */
+function getExplicitEndpoints(provider: OAuthSsoProviderConfig): {
+  authorizationUrl: string;
+  tokenUrl: string;
+  userInfoUrl: string;
+} | undefined {
+  if (provider.type === 'github') {
+    return {
+      authorizationUrl: provider.authorizationUrl || 'https://github.com/login/oauth/authorize',
+      tokenUrl: provider.tokenUrl || 'https://github.com/login/oauth/access_token',
+      userInfoUrl: provider.userInfoUrl || 'https://api.github.com/user',
+    };
+  }
+
+  // For custom providers with explicit endpoints
+  if (provider.authorizationUrl && provider.tokenUrl && provider.userInfoUrl) {
+    return {
+      authorizationUrl: provider.authorizationUrl,
+      tokenUrl: provider.tokenUrl,
+      userInfoUrl: provider.userInfoUrl,
+    };
+  }
+
+  return undefined;
+}
+
+/**
+ * Initialize and cache openid-client configuration for a provider
+ */
+async function getClientConfig(
+  provider: OAuthSsoProviderConfig,
+  _callbackUrl: string,
+): Promise<client.Configuration> {
+  const cacheKey = provider.id;
+  const cached = providerConfigsCache.get(cacheKey);
+  if (cached) {
+    return cached.config;
+  }
+
+  let config: client.Configuration;
+
+  const discoveryUrl = getDiscoveryUrl(provider);
+
+  if (discoveryUrl) {
+    // Use OIDC discovery
+    config = await client.discovery(new URL(discoveryUrl), provider.clientId, provider.clientSecret);
+  } else {
+    // Use explicit endpoints for providers like GitHub
+    const endpoints = getExplicitEndpoints(provider);
+    if (!endpoints) {
+      throw new Error(
+        `Provider ${provider.id} requires either issuerUrl for OIDC discovery or explicit endpoints`,
+      );
+    }
+
+    // Create a manual server metadata configuration
+    const serverMetadata: client.ServerMetadata = {
+      issuer: provider.issuerUrl || `https://${provider.type}.oauth`,
+      authorization_endpoint: endpoints.authorizationUrl,
+      token_endpoint: endpoints.tokenUrl,
+      userinfo_endpoint: endpoints.userInfoUrl,
+    };
+
+    config = new client.Configuration(serverMetadata, provider.clientId, provider.clientSecret);
+  }
+
+  providerConfigsCache.set(cacheKey, { config, provider });
+  return config;
+}
+
+/**
+ * Generate the authorization URL for a provider
+ */
+export async function generateAuthorizationUrl(
+  providerId: string,
+  callbackUrl: string,
+  returnUrl?: string,
+): Promise<{ url: string; state: string }> {
+  const provider = await getProviderById(providerId);
+  if (!provider) {
+    throw new Error(`OAuth SSO provider not found: ${providerId}`);
+  }
+
+  const config = await getClientConfig(provider, callbackUrl);
+  const scopes = provider.scopes || getDefaultScopes(provider.type);
+
+  // Generate PKCE code verifier and challenge
+  const codeVerifier = client.randomPKCECodeVerifier();
+  const codeChallenge = await client.calculatePKCECodeChallenge(codeVerifier);
+
+  // Generate state
+  const state = crypto.randomBytes(32).toString('base64url');
+
+  // Store state for callback verification
+  stateStore.set(state, {
+    codeVerifier,
+    providerId,
+    returnUrl,
+    createdAt: Date.now(),
+  });
+
+  // Build authorization URL parameters
+  const parameters: Record<string, string> = {
+    redirect_uri: callbackUrl,
+    scope: scopes.join(' '),
+    state,
+    code_challenge: codeChallenge,
+    code_challenge_method: 'S256',
+  };
+
+  // GitHub-specific: request user email access
+  if (provider.type === 'github') {
+    // GitHub doesn't use PKCE, but we'll still store the state
+    delete parameters.code_challenge;
+    delete parameters.code_challenge_method;
+  }
+
+  const url = client.buildAuthorizationUrl(config, parameters);
+
+  return { url: url.toString(), state };
+}
+
+/**
+ * Exchange authorization code for tokens and user info
+ */
+export async function handleCallback(
+  callbackUrl: string,
+  currentUrl: string,
+  state: string,
+): Promise<{
+  user: IUser;
+  isNewUser: boolean;
+  returnUrl?: string;
+}> {
+  // Verify and retrieve state
+  const stateEntry = stateStore.get(state);
+  if (!stateEntry) {
+    throw new Error('Invalid or expired OAuth state');
+  }
+
+  // Remove used state
+  stateStore.delete(state);
+
+  const provider = await getProviderById(stateEntry.providerId);
+  if (!provider) {
+    throw new Error(`OAuth SSO provider not found: ${stateEntry.providerId}`);
+  }
+
+  const config = await getClientConfig(provider, callbackUrl);
+
+  // Exchange code for tokens
+  let tokens: client.TokenEndpointResponse;
+
+  if (provider.type === 'github') {
+    // GitHub doesn't use PKCE
+    tokens = await client.authorizationCodeGrant(config, new URL(currentUrl), {
+      expectedState: state,
+    });
+  } else {
+    // OIDC providers with PKCE
+    tokens = await client.authorizationCodeGrant(config, new URL(currentUrl), {
+      pkceCodeVerifier: stateEntry.codeVerifier,
+      expectedState: state,
+    });
+  }
+
+  // Get user info
+  const userInfo = await getUserInfo(provider, config, tokens);
+
+  // Find or create user
+  const { user, isNewUser } = await findOrCreateUser(provider, userInfo);
+
+  return {
+    user,
+    isNewUser,
+    returnUrl: stateEntry.returnUrl,
+  };
+}
+
+/**
+ * Fetch user info from the provider
+ */
+async function getUserInfo(
+  provider: OAuthSsoProviderConfig,
+  config: client.Configuration,
+  tokens: client.TokenEndpointResponse,
+): Promise<{
+  sub: string;
+  email?: string;
+  name?: string;
+  picture?: string;
+  groups?: string[];
+  roles?: string[];
+  [key: string]: unknown;
+}> {
+  if (provider.type === 'github') {
+    // GitHub uses a different API for user info
+    const response = await fetch('https://api.github.com/user', {
+      headers: {
+        Authorization: `Bearer ${tokens.access_token}`,
+        Accept: 'application/json',
+      },
+    });
+
+    if (!response.ok) {
+      throw new Error(`Failed to fetch GitHub user info: ${response.statusText}`);
+    }
+
+    const data = (await response.json()) as GitHubUserResponse;
+
+    // Fetch email separately if not public
+    let email = data.email;
+    if (!email) {
+      const emailResponse = await fetch('https://api.github.com/user/emails', {
+        headers: {
+          Authorization: `Bearer ${tokens.access_token}`,
+          Accept: 'application/json',
+        },
+      });
+
+      if (emailResponse.ok) {
+        const emails = (await emailResponse.json()) as GitHubEmailResponse[];
+        const primaryEmail = emails.find((e) => e.primary);
+        email = primaryEmail?.email || emails[0]?.email;
+      }
+    }
+
+    return {
+      sub: String(data.id),
+      email,
+      name: data.name || data.login,
+      picture: data.avatar_url,
+    };
+  }
+
+  // Standard OIDC userinfo endpoint
+  const userInfoResponse = await client.fetchUserInfo(config, tokens.access_token!, client.skipSubjectCheck);
+
+  return {
+    sub: userInfoResponse.sub,
+    email: userInfoResponse.email as string | undefined,
+    name: userInfoResponse.name as string | undefined,
+    picture: userInfoResponse.picture as string | undefined,
+    groups: userInfoResponse.groups as string[] | undefined,
+    roles: userInfoResponse.roles as string[] | undefined,
+  };
+}
+
+/**
+ * Find existing user or create new one based on OAuth profile
+ */
+async function findOrCreateUser(
+  provider: OAuthSsoProviderConfig,
+  userInfo: {
+    sub: string;
+    email?: string;
+    name?: string;
+    picture?: string;
+    groups?: string[];
+    roles?: string[];
+    [key: string]: unknown;
+  },
+): Promise<{ user: IUser; isNewUser: boolean }> {
+  const userDao = getUserDao();
+
+  // Generate a unique username based on provider and subject
+  const oauthUsername = `${provider.id}:${userInfo.sub}`;
+
+  // Try to find existing user by OAuth identity
+  let user = await userDao.findByUsername(oauthUsername);
+
+  if (user) {
+    // Update user info if changed
+    const updates: Partial<IUser> = {};
+    if (userInfo.email && userInfo.email !== user.email) {
+      updates.email = userInfo.email;
+    }
+    if (userInfo.name && userInfo.name !== user.displayName) {
+      updates.displayName = userInfo.name;
+    }
+    if (userInfo.picture && userInfo.picture !== user.avatarUrl) {
+      updates.avatarUrl = userInfo.picture;
+    }
+
+    // Check admin status based on claims
+    const isAdmin = checkAdminClaim(provider, userInfo);
+    if (isAdmin !== user.isAdmin) {
+      updates.isAdmin = isAdmin;
+    }
+
+    if (Object.keys(updates).length > 0) {
+      await userDao.update(oauthUsername, updates);
+      user = { ...user, ...updates };
+    }
+
+    return { user, isNewUser: false };
+  }
+
+  // Check if auto-provisioning is enabled
+  if (provider.autoProvision === false) {
+    throw new Error(
+      `User not found and auto-provisioning is disabled for provider: ${provider.name}`,
+    );
+  }
+
+  // Create new user
+  const isAdmin = checkAdminClaim(provider, userInfo) || provider.defaultAdmin === true;
+
+  // Generate a random password for OAuth users (they won't use it)
+  const randomPassword = crypto.randomBytes(32).toString('hex');
+
+  const newUser = await userDao.createWithHashedPassword(oauthUsername, randomPassword, isAdmin);
+
+  // Update with OAuth-specific fields
+  const updatedUser = await userDao.update(oauthUsername, {
+    oauthProvider: provider.id,
+    oauthSubject: userInfo.sub,
+    email: userInfo.email,
+    displayName: userInfo.name,
+    avatarUrl: userInfo.picture,
+  });
+
+  return { user: updatedUser || newUser, isNewUser: true };
+}
+
+/**
+ * Check if user should be granted admin based on provider claims
+ */
+function checkAdminClaim(
+  provider: OAuthSsoProviderConfig,
+  userInfo: { groups?: string[]; roles?: string[]; [key: string]: unknown },
+): boolean {
+  if (!provider.adminClaim || !provider.adminClaimValues?.length) {
+    return false;
+  }
+
+  const claimValue = userInfo[provider.adminClaim];
+  if (!claimValue) {
+    return false;
+  }
+
+  // Handle array claims (groups, roles)
+  if (Array.isArray(claimValue)) {
+    return claimValue.some((v) => provider.adminClaimValues!.includes(String(v)));
+  }
+
+  // Handle string claims
+  return provider.adminClaimValues.includes(String(claimValue));
+}
+
+/**
+ * Get public provider info for frontend
+ */
+export async function getPublicProviderInfo(): Promise<
+  Array<{
+    id: string;
+    name: string;
+    type: string;
+    icon?: string;
+    buttonText?: string;
+  }>
+> {
+  const providers = await getEnabledProviders();
+  return providers.map((p) => ({
+    id: p.id,
+    name: p.name,
+    type: p.type,
+    icon: p.icon || p.type,
+    buttonText: p.buttonText,
+  }));
+}
+
+/**
+ * Check if local auth is allowed
+ */
+export async function isLocalAuthAllowed(): Promise<boolean> {
+  const config = await getOAuthSsoConfig();
+  // Default to true if not configured or SSO is disabled
+  if (!config?.enabled) {
+    return true;
+  }
+  return config.allowLocalAuth !== false;
+}
+
+/**
+ * Clear provider configuration cache
+ */
+export function clearProviderCache(): void {
+  providerConfigsCache.clear();
+}
--- a/src/types/index.ts
+++ b/src/types/index.ts
@@ -10,6 +10,12 @@ export interface IUser {
  username: string;
  password: string;
  isAdmin?: boolean;
+  // OAuth SSO fields
+  oauthProvider?: string; // OAuth provider ID (e.g., 'google', 'microsoft', 'github')
+  oauthSubject?: string; // OAuth subject (unique user ID from provider)
+  email?: string; // User email (from OAuth profile)
+  displayName?: string; // Display name (from OAuth profile)
+  avatarUrl?: string; // Avatar URL (from OAuth profile)
 }

 // Group interface for server grouping
@@ -124,6 +130,43 @@ export interface MCPRouterCallToolResponse {
  isError: boolean;
 }

+// OAuth SSO Provider Configuration for user authentication
+export type OAuthSsoProviderType = 'google' | 'microsoft' | 'github' | 'oidc';
+
+export interface OAuthSsoProviderConfig {
+  id: string; // Unique identifier for this provider (e.g., 'google', 'my-company-sso')
+  type: OAuthSsoProviderType; // Provider type
+  name: string; // Display name (e.g., 'Google', 'Microsoft', 'Company SSO')
+  enabled?: boolean; // Whether this provider is enabled (default: true)
+  clientId: string; // OAuth client ID
+  clientSecret: string; // OAuth client secret
+  // For OIDC providers, discovery URL or explicit endpoints
+  issuerUrl?: string; // OIDC issuer URL for auto-discovery (e.g., 'https://accounts.google.com')
+  // Explicit endpoints (optional, can be auto-discovered for OIDC)
+  authorizationUrl?: string; // OAuth authorization endpoint
+  tokenUrl?: string; // OAuth token endpoint
+  userInfoUrl?: string; // OAuth userinfo endpoint
+  // Scope configuration
+  scopes?: string[]; // OAuth scopes to request (default varies by provider)
+  // Role/admin mapping
+  adminClaim?: string; // Claim name to check for admin role (e.g., 'groups', 'roles')
+  adminClaimValues?: string[]; // Values that grant admin access (e.g., ['admin', 'mcphub-admins'])
+  // Auto-provisioning options
+  autoProvision?: boolean; // Auto-create users on first login (default: true)
+  defaultAdmin?: boolean; // Whether auto-provisioned users are admins by default (default: false)
+  // UI options
+  icon?: string; // Icon identifier for UI (e.g., 'google', 'microsoft', 'github', 'key')
+  buttonText?: string; // Custom button text (e.g., 'Sign in with Google')
+}
+
+// OAuth SSO configuration in SystemConfig
+export interface OAuthSsoConfig {
+  enabled?: boolean; // Enable/disable OAuth SSO globally
+  providers?: OAuthSsoProviderConfig[]; // List of configured SSO providers
+  allowLocalAuth?: boolean; // Allow local username/password auth alongside SSO (default: true)
+  callbackBaseUrl?: string; // Base URL for OAuth callbacks (auto-detected if not set)
+}
+
 // OAuth Provider Configuration for MCP Authorization Server
 export interface OAuthProviderConfig {
  enabled?: boolean; // Enable/disable OAuth provider
@@ -172,6 +215,7 @@ export interface SystemConfig {
  nameSeparator?: string; // Separator used between server name and tool/prompt name (default: '-')
  oauth?: OAuthProviderConfig; // OAuth provider configuration for upstream MCP servers
  oauthServer?: OAuthServerConfig; // OAuth authorization server configuration for MCPHub itself
+  oauthSso?: OAuthSsoConfig; // OAuth SSO configuration for user authentication
  enableSessionRebuild?: boolean; // Controls whether server session rebuild is enabled
 }

@@ -481,51 +525,3 @@ export interface BatchCreateGroupsResponse {
  failureCount: number; // Number of groups that failed
  results: BatchGroupResult[]; // Detailed results for each group
 }
-
-// Tool call activity interface for logging tool invocations (DB mode only)
-export interface IToolCallActivity {
-  id?: string;
-  serverName: string;
-  toolName: string;
-  keyId?: string;
-  keyName?: string;
-  status: 'pending' | 'success' | 'error';
-  request?: string;
-  response?: string;
-  errorMessage?: string;
-  durationMs?: number;
-  clientIp?: string;
-  sessionId?: string;
-  groupName?: string;
-  createdAt?: Date;
-}
-
-// Tool call activity search parameters
-export interface IToolCallActivitySearchParams {
-  serverName?: string;
-  toolName?: string;
-  keyId?: string;
-  status?: 'pending' | 'success' | 'error';
-  groupName?: string;
-  startDate?: Date;
-  endDate?: Date;
-  searchQuery?: string;
-}
-
-// Tool call activity pagination result
-export interface IToolCallActivityPage {
-  items: IToolCallActivity[];
-  total: number;
-  page: number;
-  pageSize: number;
-  totalPages: number;
-}
-
-// Tool call activity statistics
-export interface IToolCallActivityStats {
-  total: number;
-  success: number;
-  error: number;
-  pending: number;
-  avgDurationMs: number;
-}
--- a/src/utils/migration.ts
+++ b/src/utils/migration.ts
@@ -46,6 +46,11 @@ export async function migrateToDatabase(): Promise<boolean> {
            username: user.username,
            password: user.password,
            isAdmin: user.isAdmin || false,
+            oauthProvider: user.oauthProvider,
+            oauthSubject: user.oauthSubject,
+            email: user.email,
+            displayName: user.displayName,
+            avatarUrl: user.avatarUrl,
          });
          console.log(`  - Created user: ${user.username}`);
        } else {
@@ -116,6 +121,7 @@ export async function migrateToDatabase(): Promise<boolean> {
        nameSeparator: settings.systemConfig.nameSeparator,
        oauth: settings.systemConfig.oauth || {},
        oauthServer: settings.systemConfig.oauthServer || {},
+        oauthSso: settings.systemConfig.oauthSso || {},
        enableSessionRebuild: settings.systemConfig.enableSessionRebuild,
      };
      await systemConfigRepo.update(systemConfig);
--- a/tests/services/oauthSsoService.test.ts
+++ b/tests/services/oauthSsoService.test.ts
@@ -0,0 +1,235 @@
+// Mock openid-client before importing services
+jest.mock('openid-client', () => ({
+  discovery: jest.fn(),
+  Configuration: jest.fn(),
+  randomPKCECodeVerifier: jest.fn(() => 'test-verifier'),
+  calculatePKCECodeChallenge: jest.fn(() => Promise.resolve('test-challenge')),
+  buildAuthorizationUrl: jest.fn(() => new URL('https://example.com/authorize')),
+  authorizationCodeGrant: jest.fn(),
+  fetchUserInfo: jest.fn(),
+  skipSubjectCheck: Symbol('skipSubjectCheck'),
+}));
+
+// Mock the DAO module
+jest.mock('../../src/dao/index.js', () => ({
+  getSystemConfigDao: jest.fn(),
+  getUserDao: jest.fn(),
+}));
+
+import * as daoModule from '../../src/dao/index.js';
+import {
+  isOAuthSsoEnabled,
+  getEnabledProviders,
+  getProviderById,
+  isLocalAuthAllowed,
+  getPublicProviderInfo,
+  clearProviderCache,
+  stopStateCleanup,
+} from '../../src/services/oauthSsoService.js';
+
+describe('OAuth SSO Service', () => {
+  const mockGetSystemConfigDao = daoModule.getSystemConfigDao as jest.MockedFunction<
+    typeof daoModule.getSystemConfigDao
+  >;
+  const mockGetUserDao = daoModule.getUserDao as jest.MockedFunction<typeof daoModule.getUserDao>;
+
+  // Stop the cleanup interval to prevent Jest from hanging
+  afterAll(() => {
+    stopStateCleanup();
+  });
+
+  const defaultSsoConfig = {
+    enabled: true,
+    allowLocalAuth: true,
+    providers: [
+      {
+        id: 'google',
+        type: 'google' as const,
+        name: 'Google',
+        enabled: true,
+        clientId: 'test-client-id',
+        clientSecret: 'test-client-secret',
+        scopes: ['openid', 'email', 'profile'],
+      },
+      {
+        id: 'github',
+        type: 'github' as const,
+        name: 'GitHub',
+        enabled: true,
+        clientId: 'test-github-client',
+        clientSecret: 'test-github-secret',
+      },
+      {
+        id: 'disabled-provider',
+        type: 'oidc' as const,
+        name: 'Disabled',
+        enabled: false,
+        clientId: 'disabled-client',
+        clientSecret: 'disabled-secret',
+      },
+    ],
+  };
+
+  beforeEach(() => {
+    jest.clearAllMocks();
+    clearProviderCache();
+
+    mockGetSystemConfigDao.mockReturnValue({
+      get: jest.fn().mockResolvedValue({
+        oauthSso: defaultSsoConfig,
+      }),
+    } as any);
+
+    mockGetUserDao.mockReturnValue({
+      findByUsername: jest.fn().mockResolvedValue(null),
+      createWithHashedPassword: jest.fn().mockResolvedValue({
+        username: 'google:12345',
+        password: 'hashed',
+        isAdmin: false,
+      }),
+      update: jest.fn().mockImplementation((username: string, data: any) =>
+        Promise.resolve({
+          username,
+          password: 'hashed',
+          isAdmin: false,
+          ...data,
+        })
+      ),
+    } as any);
+  });
+
+  describe('isOAuthSsoEnabled', () => {
+    it('should return true when OAuth SSO is enabled with providers', async () => {
+      const enabled = await isOAuthSsoEnabled();
+      expect(enabled).toBe(true);
+    });
+
+    it('should return false when OAuth SSO is disabled', async () => {
+      mockGetSystemConfigDao.mockReturnValue({
+        get: jest.fn().mockResolvedValue({
+          oauthSso: { ...defaultSsoConfig, enabled: false },
+        }),
+      } as any);
+
+      const enabled = await isOAuthSsoEnabled();
+      expect(enabled).toBe(false);
+    });
+
+    it('should return false when no providers are configured', async () => {
+      mockGetSystemConfigDao.mockReturnValue({
+        get: jest.fn().mockResolvedValue({
+          oauthSso: { ...defaultSsoConfig, providers: [] },
+        }),
+      } as any);
+
+      const enabled = await isOAuthSsoEnabled();
+      expect(enabled).toBe(false);
+    });
+  });
+
+  describe('getEnabledProviders', () => {
+    it('should return only enabled providers', async () => {
+      const providers = await getEnabledProviders();
+      expect(providers).toHaveLength(2);
+      expect(providers.map((p) => p.id)).toContain('google');
+      expect(providers.map((p) => p.id)).toContain('github');
+      expect(providers.map((p) => p.id)).not.toContain('disabled-provider');
+    });
+
+    it('should return empty array when SSO is disabled', async () => {
+      mockGetSystemConfigDao.mockReturnValue({
+        get: jest.fn().mockResolvedValue({
+          oauthSso: { ...defaultSsoConfig, enabled: false },
+        }),
+      } as any);
+
+      const providers = await getEnabledProviders();
+      expect(providers).toHaveLength(0);
+    });
+  });
+
+  describe('getProviderById', () => {
+    it('should return the correct provider by ID', async () => {
+      const provider = await getProviderById('google');
+      expect(provider).toBeDefined();
+      expect(provider?.id).toBe('google');
+      expect(provider?.type).toBe('google');
+      expect(provider?.name).toBe('Google');
+    });
+
+    it('should return undefined for non-existent provider', async () => {
+      const provider = await getProviderById('non-existent');
+      expect(provider).toBeUndefined();
+    });
+
+    it('should return undefined for disabled provider', async () => {
+      const provider = await getProviderById('disabled-provider');
+      expect(provider).toBeUndefined();
+    });
+  });
+
+  describe('isLocalAuthAllowed', () => {
+    it('should return true when local auth is allowed', async () => {
+      const allowed = await isLocalAuthAllowed();
+      expect(allowed).toBe(true);
+    });
+
+    it('should return false when local auth is disabled', async () => {
+      mockGetSystemConfigDao.mockReturnValue({
+        get: jest.fn().mockResolvedValue({
+          oauthSso: { ...defaultSsoConfig, allowLocalAuth: false },
+        }),
+      } as any);
+
+      const allowed = await isLocalAuthAllowed();
+      expect(allowed).toBe(false);
+    });
+
+    it('should return true when SSO is disabled (fallback)', async () => {
+      mockGetSystemConfigDao.mockReturnValue({
+        get: jest.fn().mockResolvedValue({
+          oauthSso: undefined,
+        }),
+      } as any);
+
+      const allowed = await isLocalAuthAllowed();
+      expect(allowed).toBe(true);
+    });
+  });
+
+  describe('getPublicProviderInfo', () => {
+    it('should return public info for enabled providers only', async () => {
+      const info = await getPublicProviderInfo();
+      expect(info).toHaveLength(2);
+
+      const googleInfo = info.find((p) => p.id === 'google');
+      expect(googleInfo).toBeDefined();
+      expect(googleInfo?.name).toBe('Google');
+      expect(googleInfo?.type).toBe('google');
+      expect(googleInfo?.icon).toBe('google');
+
+      // Ensure sensitive data is not exposed
+      expect((googleInfo as any)?.clientSecret).toBeUndefined();
+      expect((googleInfo as any)?.clientId).toBeUndefined();
+    });
+
+    it('should include buttonText when specified', async () => {
+      mockGetSystemConfigDao.mockReturnValue({
+        get: jest.fn().mockResolvedValue({
+          oauthSso: {
+            ...defaultSsoConfig,
+            providers: [
+              {
+                ...defaultSsoConfig.providers[0],
+                buttonText: 'Login with Google',
+              },
+            ],
+          },
+        }),
+      } as any);
+
+      const info = await getPublicProviderInfo();
+      expect(info[0].buttonText).toBe('Login with Google');
+    });
+  });
+});