@lobehub/lobehub 2.0.0-next.354 → 2.0.0-next.356

package/scripts/nextauth-to-betterauth/verify.ts

@@ -0,0 +1,188 @@
+/* eslint-disable unicorn/prefer-top-level-await */
+import { getMigrationMode } from './_internal/config';
+import { db, pool, schema } from './_internal/db';
+
+type ExpectedAccount = {
+  accountId: string;
+  providerId: string;
+  scope?: string;
+  userId: string;
+};
+
+type ActualAccount = {
+  accountId: string;
+  providerId: string;
+  scope: string | null;
+  userId: string;
+};
+
+const MAX_SAMPLES = 5;
+
+const formatDuration = (ms: number) => `${(ms / 1000).toFixed(1)}s`;
+
+function buildAccountKey(account: { accountId: string; providerId: string; userId: string }) {
+  return `${account.userId}__${account.providerId}__${account.accountId}`;
+}
+
+async function loadNextAuthAccounts() {
+  const rows = await db.select().from(schema.nextauthAccounts);
+  return rows;
+}
+
+async function loadActualAccounts() {
+  const rows = await db
+    .select({
+      accountId: schema.account.accountId,
+      providerId: schema.account.providerId,
+      scope: schema.account.scope,
+      userId: schema.account.userId,
+    })
+    .from(schema.account);
+
+  return rows as ActualAccount[];
+}
+
+function buildExpectedAccounts(nextauthAccounts: Awaited<ReturnType<typeof loadNextAuthAccounts>>) {
+  const expectedAccounts: ExpectedAccount[] = [];
+
+  for (const nextauthAccount of nextauthAccounts) {
+    expectedAccounts.push({
+      accountId: nextauthAccount.providerAccountId,
+      providerId: nextauthAccount.provider,
+      scope: nextauthAccount.scope ?? undefined,
+      userId: nextauthAccount.userId,
+    });
+  }
+
+  return { expectedAccounts };
+}
+
+async function main() {
+  const startedAt = Date.now();
+  const mode = getMigrationMode();
+
+  console.log('');
+  console.log('╔════════════════════════════════════════════════════════════╗');
+  console.log('║     NextAuth to Better Auth Verification Script            ║');
+  console.log('╠════════════════════════════════════════════════════════════╣');
+  console.log(`║  Mode:     ${mode.padEnd(48)}║`);
+  console.log('╚════════════════════════════════════════════════════════════╝');
+  console.log('');
+
+  const [nextauthAccounts, actualAccounts] = await Promise.all([
+    loadNextAuthAccounts(),
+    loadActualAccounts(),
+  ]);
+
+  console.log(`📦 [verify] Loaded nextauth_accounts=${nextauthAccounts.length}`);
+
+  const { expectedAccounts } = buildExpectedAccounts(nextauthAccounts);
+
+  console.log(`🧮 [verify] Expected accounts=${expectedAccounts.length}`);
+  console.log(`🗄️ [verify] DB snapshot: accounts=${actualAccounts.length}`);
+
+  const expectedAccountSet = new Set(expectedAccounts.map(buildAccountKey));
+  const actualAccountSet = new Set(actualAccounts.map(buildAccountKey));
+
+  let missingAccounts = 0;
+  const missingAccountSamples: string[] = [];
+  for (const account of expectedAccounts) {
+    const key = buildAccountKey(account);
+    if (!actualAccountSet.has(key)) {
+      missingAccounts += 1;
+      if (missingAccountSamples.length < MAX_SAMPLES) {
+        missingAccountSamples.push(`${account.providerId}/${account.accountId}`);
+      }
+    }
+  }
+
+  let unexpectedAccounts = 0;
+  const unexpectedAccountSamples: string[] = [];
+  for (const account of actualAccounts) {
+    const key = buildAccountKey(account);
+    if (!expectedAccountSet.has(key)) {
+      unexpectedAccounts += 1;
+      if (unexpectedAccountSamples.length < MAX_SAMPLES) {
+        unexpectedAccountSamples.push(`${account.providerId}/${account.accountId}`);
+      }
+    }
+  }
+
+  // Provider counts
+  const expectedProviderCounts: Record<string, number> = {};
+  const actualProviderCounts: Record<string, number> = {};
+
+  for (const account of expectedAccounts) {
+    expectedProviderCounts[account.providerId] =
+      (expectedProviderCounts[account.providerId] ?? 0) + 1;
+  }
+
+  for (const account of actualAccounts) {
+    actualProviderCounts[account.providerId] = (actualProviderCounts[account.providerId] ?? 0) + 1;
+  }
+
+  const formatCounts = (counts: Record<string, number>) =>
+    Object.entries(counts)
+      .sort((a, b) => b[1] - a[1] || a[0].localeCompare(b[0]))
+      .map(([providerId, count]) => `${providerId}=${count}`)
+      .join(', ');
+
+  console.log(
+    `📊 [verify] Expected provider counts: ${formatCounts(expectedProviderCounts) || 'n/a'}`,
+  );
+  console.log(
+    `📊 [verify] Actual provider counts:   ${formatCounts(actualProviderCounts) || 'n/a'}`,
+  );
+
+  // Check for missing scope in actual accounts
+  let missingScopeNonCredential = 0;
+  const sampleMissingScope: string[] = [];
+
+  for (const account of actualAccounts) {
+    if (account.providerId !== 'credential' && !account.scope) {
+      // Find corresponding nextauth account to check if it had scope
+      const nextauthAccount = nextauthAccounts.find(
+        (na) => na.provider === account.providerId && na.providerAccountId === account.accountId,
+      );
+      if (nextauthAccount?.scope) {
+        missingScopeNonCredential += 1;
+        if (sampleMissingScope.length < MAX_SAMPLES) {
+          sampleMissingScope.push(`${account.providerId}/${account.accountId}`);
+        }
+      }
+    }
+  }
+
+  console.log('');
+  console.log('📋 [verify] Summary:');
+  console.log(
+    `   - Missing accounts: ${missingAccounts} ${missingAccountSamples.length > 0 ? `(samples: ${missingAccountSamples.join(', ')})` : ''}`,
+  );
+  console.log(
+    `   - Unexpected accounts: ${unexpectedAccounts} ${unexpectedAccountSamples.length > 0 ? `(samples: ${unexpectedAccountSamples.join(', ')})` : '(accounts not from nextauth)'}`,
+  );
+  console.log(
+    `   - Missing scope (had in nextauth): ${missingScopeNonCredential} ${sampleMissingScope.length > 0 ? `(samples: ${sampleMissingScope.join(', ')})` : ''}`,
+  );
+
+  console.log('');
+  if (missingAccounts === 0) {
+    console.log(
+      `✅ Verification success! All nextauth accounts migrated. (${formatDuration(Date.now() - startedAt)})`,
+    );
+  } else {
+    console.log(
+      `⚠️ Verification completed with ${missingAccounts} missing accounts. (${formatDuration(Date.now() - startedAt)})`,
+    );
+  }
+}
+
+void main()
+  .catch((error) => {
+    console.log('');
+    console.error('❌ Verification failed:', error);
+    process.exitCode = 1;
+  })
+  .finally(async () => {
+    await pool.end();
+  });

package/scripts/prebuild.mts

@@ -9,10 +9,11 @@ import { fileURLToPath } from 'node:url';
 
 // Use createRequire for CommonJS module compatibility
 const require = createRequire(import.meta.url);
-const { checkDeprecatedClerkEnv } = require('./_shared/checkDeprecatedClerkEnv.js');
+const { checkDeprecatedAuth } = require('./_shared/checkDeprecatedAuth.js');
 
 const isDesktop = process.env.NEXT_PUBLIC_IS_DESKTOP_APP === '1';
 const isBundleAnalyzer = process.env.ANALYZE === 'true' && process.env.CI === 'true';
+const isServerDB = !!process.env.DATABASE_URL;
 
 if (isDesktop) {
   dotenvExpand.expand(dotenv.config({ path: '.env.desktop' }));
@@ -21,10 +22,40 @@ if (isDesktop) {
   dotenvExpand.expand(dotenv.config());
 }
 
-// Auth flags - use process.env directly for build-time dead code elimination
-// Better Auth is the default auth solution when NextAuth is not explicitly enabled
-const enableNextAuth = process.env.NEXT_PUBLIC_ENABLE_NEXT_AUTH === '1';
-const enableBetterAuth = !enableNextAuth;
+const AUTH_SECRET_DOC_URL = 'https://lobehub.com/docs/self-hosting/environment-variables/auth#auth-secret';
+const KEY_VAULTS_SECRET_DOC_URL = 'https://lobehub.com/docs/self-hosting/environment-variables/basic#key-vaults-secret';
+
+/**
+ * Check for required environment variables in server database mode
+ */
+const checkRequiredEnvVars = () => {
+  if (isDesktop || !isServerDB) return;
+
+  const missingVars: { docUrl: string; name: string }[] = [];
+
+  if (!process.env.AUTH_SECRET) {
+    missingVars.push({ docUrl: AUTH_SECRET_DOC_URL, name: 'AUTH_SECRET' });
+  }
+
+  if (!process.env.KEY_VAULTS_SECRET) {
+    missingVars.push({ docUrl: KEY_VAULTS_SECRET_DOC_URL, name: 'KEY_VAULTS_SECRET' });
+  }
+
+  if (missingVars.length > 0) {
+    console.error('\n' + '═'.repeat(70));
+    console.error('❌ ERROR: Missing required environment variables!');
+    console.error('═'.repeat(70));
+    console.error('\nThe following environment variables are required for server database mode:\n');
+    for (const { name, docUrl } of missingVars) {
+      console.error(`  • ${name}`);
+      console.error(`    📖 Documentation: ${docUrl}\n`);
+    }
+    console.error('Please configure these environment variables and redeploy.');
+    console.error('═'.repeat(70) + '\n');
+    process.exit(1);
+  }
+};
+
 
 const getCommandVersion = (command: string): string | null => {
   try {
@@ -58,13 +89,32 @@ const printEnvInfo = () => {
   console.log(`    VERCEL_PROJECT_PRODUCTION_URL: ${process.env.VERCEL_PROJECT_PRODUCTION_URL ?? '(not set)'}`);
   console.log(`    AUTH_EMAIL_VERIFICATION: ${process.env.AUTH_EMAIL_VERIFICATION ?? '(not set)'}`);
   console.log(`    ENABLE_MAGIC_LINK: ${process.env.ENABLE_MAGIC_LINK ?? '(not set)'}`);
-  console.log(`    AUTH_SECRET: ${process.env.AUTH_SECRET ? '✓ set' : '✗ not set'}`);
-  console.log(`    KEY_VAULTS_SECRET: ${process.env.KEY_VAULTS_SECRET ? '✓ set' : '✗ not set'}`);
 
-  // Auth flags
-  console.log('\n  Auth Flags:');
-  console.log(`    enableBetterAuth: ${enableBetterAuth}`);
-  console.log(`    enableNextAuth: ${enableNextAuth}`);
+  // Check SSO providers configuration
+  const ssoProviders = process.env.AUTH_SSO_PROVIDERS;
+  console.log(`    AUTH_SSO_PROVIDERS: ${ssoProviders ?? '(not set)'}`);
+
+  if (ssoProviders) {
+    const getEnvPrefix = (provider: string) => `AUTH_${provider.toUpperCase().replaceAll('-', '_')}`;
+
+    const providers = ssoProviders.split(/[,，]/).map(p => p.trim()).filter(Boolean);
+    const missingProviders: string[] = [];
+
+    for (const provider of providers) {
+      const envPrefix = getEnvPrefix(provider);
+      const hasEnvVar = Object.keys(process.env).some(key => key.startsWith(envPrefix));
+      if (!hasEnvVar) {
+        missingProviders.push(provider);
+      }
+    }
+
+    if (missingProviders.length > 0) {
+      console.log('\n  ⚠️  SSO Provider Configuration Warning:');
+      for (const provider of missingProviders) {
+        console.log(`    - "${provider}" is configured but no ${getEnvPrefix(provider)}_* env vars found`);
+      }
+    }
+  }
 
   console.log('─'.repeat(50));
 };
@@ -160,8 +210,11 @@ export const runPrebuild = async (targetDir: string = 'src') => {
 const isMainModule = process.argv[1] === fileURLToPath(import.meta.url);
 
 if (isMainModule) {
-  // Check for deprecated Clerk env vars first - fail fast if found
-  checkDeprecatedClerkEnv();
+  // Check for deprecated auth env vars first - fail fast if found
+  checkDeprecatedAuth();
+
+  // Check for required env vars in server database mode
+  checkRequiredEnvVars();
 
   printEnvInfo();
   // 执行删除操作

package/scripts/serverLauncher/startServer.js

@@ -7,11 +7,11 @@ const { existsSync } = require('node:fs');
 // Resolve shared module path for both local dev and Docker environments
 // Local: scripts/serverLauncher/startServer.js -> scripts/_shared/...
 // Docker: /app/startServer.js -> /app/scripts/_shared/...
-const localPath = path.join(__dirname, '..', '_shared', 'checkDeprecatedClerkEnv.js');
-const dockerPath = '/app/scripts/_shared/checkDeprecatedClerkEnv.js';
+const localPath = path.join(__dirname, '..', '_shared', 'checkDeprecatedAuth.js');
+const dockerPath = '/app/scripts/_shared/checkDeprecatedAuth.js';
 const sharedModulePath = existsSync(localPath) ? localPath : dockerPath;
 
-const { checkDeprecatedClerkEnv } = require(sharedModulePath);
+const { checkDeprecatedAuth } = require(sharedModulePath);
 
 // Set file paths
 const DB_MIGRATION_SCRIPT_PATH = '/app/docker.cjs';
@@ -139,8 +139,8 @@ const runServer = async () => {
 
 // Main execution block
 (async () => {
-  // Check for deprecated Clerk env vars first - fail fast if found
-  checkDeprecatedClerkEnv({ action: 'restart' });
+  // Check for deprecated auth env vars first - fail fast if found
+  checkDeprecatedAuth({ action: 'restart' });
 
   console.log('🌐 DNS Server:', dns.getServers());
   console.log('-------------------------------------');

package/src/app/(backend)/api/auth/[...all]/route.ts

@@ -1,32 +1,14 @@
+import { toNextJsHandler } from 'better-auth/next-js';
 import type { NextRequest } from 'next/server';
 
-import { enableBetterAuth, enableNextAuth } from '@/envs/auth';
+import { auth } from '@/auth';
 
-const createHandler = async () => {
-  if (enableBetterAuth) {
-    const [{ toNextJsHandler }, { auth }] = await Promise.all([
-      import('better-auth/next-js'),
-      import('@/auth'),
-    ]);
-    return toNextJsHandler(auth);
-  }
-
-  if (enableNextAuth) {
-    const NextAuthNode = await import('@/libs/next-auth');
-    return NextAuthNode.default.handlers;
-  }
-
-  return { GET: undefined, POST: undefined };
-};
-
-const handler = createHandler();
+const handler = toNextJsHandler(auth);
 
 export const GET = async (req: NextRequest) => {
-  const { GET } = await handler;
-  return GET?.(req);
+  return handler.GET(req);
 };
 
 export const POST = async (req: NextRequest) => {
-  const { POST } = await handler;
-  return POST?.(req);
+  return handler.POST(req);
 };

package/src/app/(backend)/api/webhooks/casdoor/route.ts

@@ -3,7 +3,7 @@ import { NextResponse } from 'next/server';
 import { serverDB } from '@/database/server';
 import { authEnv } from '@/envs/auth';
 import { pino } from '@/libs/logger';
-import { NextAuthUserService } from '@/server/services/nextAuthUser';
+import { WebhookUserService } from '@/server/services/webhookUser';
 
 import { validateRequest } from './validateRequest';
 
@@ -19,13 +19,13 @@ export const POST = async (req: Request): Promise<NextResponse> => {
 
   const { action, object } = payload;
 
-  const nextAuthUserService = new NextAuthUserService(serverDB);
+  const webhookUserService = new WebhookUserService(serverDB);
   switch (action) {
     case 'update-user': {
-      return nextAuthUserService.safeUpdateUser(
+      return webhookUserService.safeUpdateUser(
         {
-          provider: 'casdoor',
-          providerAccountId: object.id,
+          accountId: object.id,
+          providerId: 'casdoor',
         },
         {
           avatar: object?.avatar,

package/src/app/(backend)/api/webhooks/logto/route.ts

@@ -3,7 +3,7 @@ import { NextResponse } from 'next/server';
 import { serverDB } from '@/database/server';
 import { authEnv } from '@/envs/auth';
 import { pino } from '@/libs/logger';
-import { NextAuthUserService } from '@/server/services/nextAuthUser';
+import { WebhookUserService } from '@/server/services/webhookUser';
 
 import { validateRequest } from './validateRequest';
 
@@ -21,13 +21,13 @@ export const POST = async (req: Request): Promise<NextResponse> => {
 
   pino.trace(`logto webhook payload: ${{ data, event }}`);
 
-  const nextAuthUserService = new NextAuthUserService(serverDB);
+  const webhookUserService = new WebhookUserService(serverDB);
   switch (event) {
     case 'User.Data.Updated': {
-      return nextAuthUserService.safeUpdateUser(
+      return webhookUserService.safeUpdateUser(
         {
-          provider: 'logto',
-          providerAccountId: data.id,
+          accountId: data.id,
+          providerId: 'logto',
         },
         {
           avatar: data?.avatar,
@@ -38,9 +38,9 @@ export const POST = async (req: Request): Promise<NextResponse> => {
     }
     case 'User.SuspensionStatus.Updated': {
       if (data.isSuspended) {
-        return nextAuthUserService.safeSignOutUser({
-          provider: 'logto',
-          providerAccountId: data.id,
+        return webhookUserService.safeSignOutUser({
+          accountId: data.id,
+          providerId: 'logto',
         });
       }
       return NextResponse.json({ message: 'user reactivated', success: true }, { status: 200 });

package/src/app/(backend)/middleware/auth/index.test.ts

@@ -24,10 +24,17 @@ vi.mock('@/envs/auth', async (importOriginal) => {
   const actual = await importOriginal<typeof import('@/envs/auth')>();
   return {
     ...actual,
-    enableBetterAuth: false,
   };
 });
 
+vi.mock('@/auth', () => ({
+  auth: {
+    api: {
+      getSession: vi.fn().mockResolvedValue(null),
+    },
+  },
+}));
+
 describe('checkAuth', () => {
   const mockHandler: RequestHandler = vi.fn();
   const mockRequest = new Request('https://example.com');

package/src/app/(backend)/middleware/auth/index.ts

@@ -6,14 +6,10 @@ import {
 import { ChatErrorType, type ClientSecretPayload } from '@lobechat/types';
 import { getXorPayload } from '@lobechat/utils/server';
 
+import { auth } from '@/auth';
 import { getServerDB } from '@/database/core/db-adaptor';
 import { type LobeChatDatabase } from '@/database/type';
-import {
-  LOBE_CHAT_AUTH_HEADER,
-  LOBE_CHAT_OIDC_AUTH_HEADER,
-  OAUTH_AUTHORIZED,
-  enableBetterAuth,
-} from '@/envs/auth';
+import { LOBE_CHAT_AUTH_HEADER, LOBE_CHAT_OIDC_AUTH_HEADER, OAUTH_AUTHORIZED } from '@/envs/auth';
 import { validateOIDCJWT } from '@/libs/oidc-provider/jwt';
 import { createErrorResponse } from '@/utils/errorResponse';
 
@@ -58,18 +54,13 @@ export const checkAuth =
       // get Authorization from header
       const authorization = req.headers.get(LOBE_CHAT_AUTH_HEADER);
       const oauthAuthorized = !!req.headers.get(OAUTH_AUTHORIZED);
-      let betterAuthAuthorized = false;
 
       // better auth handler
-      if (enableBetterAuth) {
-        const { auth: betterAuth } = await import('@/auth');
-
-        const session = await betterAuth.api.getSession({
-          headers: req.headers,
-        });
+      const session = await auth.api.getSession({
+        headers: req.headers,
+      });
 
-        betterAuthAuthorized = !!session?.user?.id;
-      }
+      const betterAuthAuthorized = !!session?.user?.id;
 
       if (!authorization) throw AgentRuntimeError.createError(ChatErrorType.Unauthorized);
 

package/src/app/(backend)/middleware/auth/utils.test.ts

@@ -2,49 +2,17 @@ import { beforeEach, describe, expect, it, vi } from 'vitest';
 
 import { checkAuthMethod } from './utils';
 
-let enableNextAuthMock = false;
-let enableBetterAuthMock = false;
-
-vi.mock('@/envs/auth', async (importOriginal) => {
-  const data = await importOriginal();
-
-  return {
-    ...(data as any),
-    get enableBetterAuth() {
-      return enableBetterAuthMock;
-    },
-    get enableNextAuth() {
-      return enableNextAuthMock;
-    },
-  };
-});
-
 describe('checkAuthMethod', () => {
   beforeEach(() => {
     vi.clearAllMocks();
   });
 
-  it('should pass with valid Next auth', () => {
-    enableNextAuthMock = true;
-    expect(() =>
-      checkAuthMethod({
-        nextAuthAuthorized: true,
-      }),
-    ).not.toThrow();
-
-    enableNextAuthMock = false;
-  });
-
   it('should pass with valid Better Auth session', () => {
-    enableBetterAuthMock = true;
-
     expect(() =>
       checkAuthMethod({
         betterAuthAuthorized: true,
       }),
     ).not.toThrow();
-
-    enableBetterAuthMock = false;
   });
 
   it('should pass with valid API key', () => {

package/src/app/(backend)/middleware/auth/utils.ts

@@ -1,5 +1,3 @@
-import { enableBetterAuth, enableNextAuth } from '@/envs/auth';
-
 interface CheckAuthParams {
   apiKey?: string;
   betterAuthAuthorized?: boolean;
@@ -11,16 +9,13 @@ interface CheckAuthParams {
  * @param {CheckAuthParams} params - Authentication parameters extracted from headers.
  * @param {string} [params.apiKey] - The user API key.
  * @param {boolean} [params.betterAuthAuthorized] - Whether the Better Auth session exists.
- * @param {boolean} [params.nextAuthAuthorized] - Whether the OAuth 2 header is provided.
+ * @param {boolean} [params.nextAuthAuthorized] - Whether the OAuth 2 header is provided (legacy, kept for compatibility).
  */
 export const checkAuthMethod = (params: CheckAuthParams) => {
-  const { apiKey, betterAuthAuthorized, nextAuthAuthorized } = params;
+  const { apiKey, betterAuthAuthorized } = params;
 
   // if better auth session exists
-  if (enableBetterAuth && betterAuthAuthorized) return;
-
-  // if next auth handler is provided
-  if (enableNextAuth && nextAuthAuthorized) return;
+  if (betterAuthAuthorized) return;
 
   // if apiKey exist
   if (apiKey) return;

package/src/app/(backend)/webapi/chat/[provider]/route.test.ts

@@ -27,10 +27,17 @@ vi.mock('@/envs/auth', async (importOriginal) => {
   const actual = await importOriginal<typeof import('@/envs/auth')>();
   return {
     ...actual,
-    enableBetterAuth: false,
   };
 });
 
+vi.mock('@/auth', () => ({
+  auth: {
+    api: {
+      getSession: vi.fn().mockResolvedValue(null),
+    },
+  },
+}));
+
 // 模拟请求和响应
 let request: Request;
 beforeEach(() => {

package/src/app/(backend)/webapi/create-image/comfyui/route.ts

@@ -21,7 +21,6 @@ const handler = async (req: Request, { jwtPayload }: { jwtPayload?: any }) => {
 
     const caller = createCaller({
       jwtPayload,
-      nextAuth: undefined, // WebAPI routes don't have nextAuth session
       userId: jwtPayload?.userId, // Required for userAuth middleware
     });
 

package/src/app/(backend)/webapi/models/[provider]/route.test.ts

@@ -21,10 +21,17 @@ vi.mock('@/envs/auth', async (importOriginal) => {
   const actual = await importOriginal<typeof import('@/envs/auth')>();
   return {
     ...actual,
-    enableBetterAuth: false,
   };
 });
 
+vi.mock('@/auth', () => ({
+  auth: {
+    api: {
+      getSession: vi.fn().mockResolvedValue(null),
+    },
+  },
+}));
+
 vi.mock('@/server/modules/ModelRuntime', () => ({
   initModelRuntimeFromDB: vi.fn(),
 }));

package/src/app/[variants]/(auth)/signin/SignInEmailStep.tsx

@@ -7,7 +7,7 @@ import { ChevronRight, Mail } from 'lucide-react';
 import { useEffect, useRef } from 'react';
 import { Trans, useTranslation } from 'react-i18next';
 
-import AuthIcons from '@/components/NextAuth/AuthIcons';
+import AuthIcons from '@/components/AuthIcons';
 import { PRIVACY_URL, TERMS_URL } from '@/const/url';
 
 import AuthCard from '../../../../features/AuthCard';

package/src/app/[variants]/(auth)/signup/[[...signup]]/page.tsx

@@ -1,5 +1,3 @@
-import { enableBetterAuth } from '@/envs/auth';
-import { notFound } from '@/libs/next/navigation';
 import { metadataModule } from '@/server/metadata';
 import { translation } from '@/server/translation';
 import { type DynamicLayoutProps } from '@/types/next';
@@ -9,28 +7,17 @@ import BetterAuthSignUpForm from './BetterAuthSignUpForm';
 
 export const generateMetadata = async (props: DynamicLayoutProps) => {
   const locale = await RouteVariants.getLocale(props);
-
-  if (enableBetterAuth) {
-    const { t } = await translation('auth', locale);
-    return metadataModule.generate({
-      description: t('betterAuth.signup.subtitle'),
-      title: t('betterAuth.signup.title'),
-      url: '/signup',
-    });
-  }
+  const { t } = await translation('auth', locale);
 
   return metadataModule.generate({
-    title: 'Sign Up',
+    description: t('betterAuth.signup.subtitle'),
+    title: t('betterAuth.signup.title'),
     url: '/signup',
   });
 };
 
 const Page = () => {
-  if (enableBetterAuth) {
-    return <BetterAuthSignUpForm />;
-  }
-
-  return notFound();
+  return <BetterAuthSignUpForm />;
 };
 
 export default Page;

package/src/app/[variants]/(main)/agent/_layout/Sidebar/Topic/List/Item/index.tsx

@@ -110,6 +110,7 @@ const TopicItem = memo<TopicItemProps>(({ id, title, fav, active, threadId }) =>
             fill={fav ? cssVar.colorWarning : 'transparent'}
             icon={Star}
             onClick={(e) => {
+              e.preventDefault();
               e.stopPropagation();
               favoriteTopic(id, !fav);
             }}