Beautiful Open-Source Form Builder
2fa (#965)
Julien Nahuma3ba0ef9c8d5
diff --git a/api/app/Http/Controllers/Auth/LoginController.php b/api/app/Http/Controllers/Auth/LoginController.phpindex 7fd079a27..fd965d486 100644--- a/api/app/Http/Controllers/Auth/LoginController.php+++ b/api/app/Http/Controllers/Auth/LoginController.php@@ -3,6 +3,7 @@namespace App\Http\Controllers\Auth;use App\Exceptions\VerifyEmailException;+use App\Http\Controllers\Auth\Traits\ManagesJWT;use App\Http\Controllers\Controller;use Illuminate\Contracts\Auth\MustVerifyEmail;use Illuminate\Foundation\Auth\AuthenticatesUsers;@@ -12,6 +13,9 @@ use Illuminate\Validation\ValidationException;class LoginController extends Controller{use AuthenticatesUsers;+ use ManagesJWT {+ ManagesJWT::sendLoginResponse as traitSendLoginResponse;+ }/*** Create a new controller instance.@@ -62,11 +66,7 @@ class LoginController extends Controllerreturn false;}- if ($user->is_blocked) {- $this->guard()->logout();- return false;- }-+ // Blocked check is now handled in sendLoginResponseWithTwoFactorCheck$guard->setToken($token);return true;@@ -87,6 +87,7 @@ class LoginController extends Controller/*** Send the response after the user was authenticated.+ * Override to use centralized logic that handles 2FA and blocked user checks.** @return \Illuminate\Http\JsonResponse*/@@ -94,13 +95,12 @@ class LoginController extends Controller{$this->clearLoginAttempts($request);- $token = (string) $this->guard()->getToken();- $expiration = $this->guard()->getPayload()->get('exp');+ $user = $this->guard()->user();- return response()->json([- 'token' => $token,- 'token_type' => 'bearer',- 'expires_in' => $expiration - time(),+ // traitSendLoginResponse() automatically handles 2FA check and blocked user check+ return $this->traitSendLoginResponse($user, [+ 'method' => 'password',+ 'remember' => $request->remember ?? false,]);}diff --git a/api/app/Http/Controllers/Auth/OAuthController.php b/api/app/Http/Controllers/Auth/OAuthController.phpindex 1513e4506..957f49ed9 100644--- a/api/app/Http/Controllers/Auth/OAuthController.php+++ b/api/app/Http/Controllers/Auth/OAuthController.php@@ -33,9 +33,9 @@ class OAuthController extends Controllerpublic function callback(Request $request, string $provider){$params = $request->all();- $result = $this->flowOrchestrator->processCallback($provider, $params);- return response()->json($result);+ // Orchestrator now returns JsonResponse directly with proper status codes+ return $this->flowOrchestrator->processCallback($provider, $params);}/**@@ -49,8 +49,7 @@ class OAuthController extends Controller'utm_data' => 'sometimes|array',]);- $result = $this->flowOrchestrator->processWidgetCallback($service, $request);-- return response()->json($result);+ // Orchestrator now returns JsonResponse directly with proper status codes+ return $this->flowOrchestrator->processWidgetCallback($service, $request);}}diff --git a/api/app/Http/Controllers/Auth/SsoController.php b/api/app/Http/Controllers/Auth/SsoController.phpindex 908c60b8d..5b4263340 100644--- a/api/app/Http/Controllers/Auth/SsoController.php+++ b/api/app/Http/Controllers/Auth/SsoController.php@@ -4,15 +4,16 @@ namespace App\Http\Controllers\Auth;use App\Enterprise\Oidc\ConnectionManager;use App\Enterprise\Oidc\IdTokenVerifier;+use App\Http\Controllers\Auth\Traits\ManagesJWT;use App\Http\Controllers\Controller;use App\Enterprise\Oidc\ProvisioningService;use Illuminate\Http\Request;-use Illuminate\Support\Facades\Auth;use Illuminate\Support\Facades\Log;-use Tymon\JWTAuth\JWTGuard;+use Symfony\Component\HttpKernel\Exception\HttpException;class SsoController extends Controller{+ use ManagesJWT;public function __construct(private ConnectionManager $connectionManager,private ProvisioningService $provisioningService,@@ -163,34 +164,22 @@ class SsoController extends Controller// Determine if this is a new user$isNewUser = !$existingUser || $existingUser->id !== $user->id;- // Check if user is blocked- if ($user->is_blocked) {- abort(403, 'Your account has been blocked. Please contact support.');- }-- // Login user using JWT guard (same as LoginController)- /** @var JWTGuard $guard */- $guard = Auth::guard('api');- $token = (string) $guard->login($user);- $expiration = $guard->getPayload()->get('exp');-- // Get intended URL or default to home- $intendedUrl = $request->cookie('intended_url') ?? '/home';-- // Return JSON response for API (when Accept: application/json header is present)- if ($request->expectsJson() || $request->wantsJson() || $request->header('Accept') === 'application/json') {- return response()->json([- 'token' => $token,- 'token_type' => 'bearer',- 'expires_in' => $expiration - time(),- 'user' => $user,- 'new_user' => $isNewUser,- 'redirect_url' => $intendedUrl,- ]);- }-- // For web requests, redirect with token in cookie or session- return redirect($intendedUrl)->with('auth_token', $token);+ // sendLoginResponse() automatically handles 2FA check and blocked user check+ // callback.vue always sends JSON, so we can directly return the response+ // HttpException (like 403 for blocked users) will be handled by the exception handler+ return $this->sendLoginResponse($user, [+ 'method' => 'oidc',+ 'slug' => $slug,+ ], [+ 'user' => $user,+ 'new_user' => $isNewUser,+ 'redirect_url' => $request->cookie('intended_url') ?? '/home',+ ]);+ } catch (HttpException $e) {+ // Handle HTTP exceptions (like 403 for blocked users) - preserve status code+ return response()->json([+ 'message' => $e->getMessage(),+ ], $e->getStatusCode());} catch (\Exception $e) {Log::error('OIDC callback failed', ['slug' => $slug,@@ -198,23 +187,10 @@ class SsoController extends Controller'trace' => $e->getTraceAsString(),]);- $errorMessage = $e->getMessage();-- // Preserve HTTP exception status codes (e.g., 403 for blocked users)- $statusCode = 400;- if ($e instanceof \Symfony\Component\HttpKernel\Exception\HttpException) {- $statusCode = $e->getStatusCode();- }-- if ($request->expectsJson()) {- return response()->json([- 'message' => $errorMessage,- ], $statusCode);- }-- // Redirect to login with error- return redirect()->route('login')- ->withErrors(['oidc' => $errorMessage]);+ // callback.vue always sends JSON, so always return JSON response+ return response()->json([+ 'message' => $e->getMessage(),+ ], 400);}}diff --git a/api/app/Http/Controllers/Auth/Traits/ManagesJWT.php b/api/app/Http/Controllers/Auth/Traits/ManagesJWT.phpindex 2b3d425f0..18bb0cfec 100644--- a/api/app/Http/Controllers/Auth/Traits/ManagesJWT.php+++ b/api/app/Http/Controllers/Auth/Traits/ManagesJWT.php@@ -3,23 +3,67 @@namespace App\Http\Controllers\Auth\Traits;use App\Models\User;+use App\Service\Auth\TwoFactorAuthService;use Illuminate\Http\JsonResponse;trait ManagesJWT{/*** Send the response after the user was authenticated.+ * Automatically handles blocked user check and 2FA verification.+ *+ * @param User $user The authenticated user+ * @param array $context Additional context (method, remember, etc.) for 2FA+ * @param array $additionalData Additional data to include in response+ * @return JsonResponse*/- protected function sendLoginResponse(User $user): JsonResponse- {+ protected function sendLoginResponse(+ User $user,+ array $context = [],+ array $additionalData = []+ ): JsonResponse {+ // Check if user is blocked+ if ($user->is_blocked) {+ // Clear any authentication before throwing exception+ // Wrap in try-catch because logout may fail if user isn't authenticated+ try {+ auth('api')->logout();+ } catch (\Exception $e) {+ // Ignore logout errors - user may not be authenticated yet+ }++ throw new \Symfony\Component\HttpKernel\Exception\HttpException(+ 403,+ 'Your account has been blocked. Please contact support.'+ );+ }++ // Check if 2FA is required+ $twoFactorService = app(TwoFactorAuthService::class);++ if ($twoFactorService->requiresVerification($user)) {+ // Logout the user since 2FA verification is required+ // The TwoFactorVerificationController uses 'guest' middleware+ auth('api')->logout();++ $pendingToken = $twoFactorService->storePendingAuth($user, $context);++ return response()->json(array_merge([+ 'requires_2fa' => true,+ 'pending_auth_token' => $pendingToken,+ 'user' => $user->only(['id', 'name', 'email']), // Minimal user data+ ], $additionalData), 422);+ }++ // No 2FA required, issue token normally$guard = auth('api');$token = $guard->login($user);- return response()->json([+ return response()->json(array_merge(['token' => $token,'token_type' => 'bearer','expires_in' => config('jwt.ttl') * 60,- 'new_user' => $user->new_user ?? false- ]);+ 'new_user' => $user->new_user ?? false,+ ], $additionalData));}}diff --git a/api/app/Http/Controllers/Auth/TwoFactorVerificationController.php b/api/app/Http/Controllers/Auth/TwoFactorVerificationController.phpnew file mode 100644index 000000000..a2a2d942c--- /dev/null+++ b/api/app/Http/Controllers/Auth/TwoFactorVerificationController.php@@ -0,0 +1,89 @@+<?php++namespace App\Http\Controllers\Auth;++use App\Http\Controllers\Auth\Traits\ManagesJWT;+use App\Http\Controllers\Controller;+use App\Service\Auth\TwoFactorAuthService;+use Illuminate\Http\Request;+use Illuminate\Support\Facades\RateLimiter;+use Illuminate\Validation\ValidationException;++class TwoFactorVerificationController extends Controller+{+ use ManagesJWT;++ public function __construct(+ private TwoFactorAuthService $twoFactorService+ ) {+ }++ /**+ * Verify 2FA code during login and complete authentication.+ */+ public function verify(Request $request)+ {+ $request->validate([+ 'pending_auth_token' => 'required|string',+ 'code' => 'required|string|min:6|max:8', // Supports both TOTP (6) and recovery codes (8)+ ]);++ // Rate limiting - use pending_auth_token to limit per-session, with IP as fallback+ $key = '2fa_verify:' . ($request->pending_auth_token ? sha1($request->pending_auth_token) : $request->ip());+ if (RateLimiter::tooManyAttempts($key, 5)) {+ $seconds = RateLimiter::availableIn($key);+ throw ValidationException::withMessages([+ 'code' => ["Too many attempts. Please try again in {$seconds} seconds."],+ ]);+ }++ RateLimiter::hit($key, 60); // 5 attempts per minute++ // Get pending auth data+ $pendingAuth = $this->twoFactorService->getPendingAuth($request->pending_auth_token);++ if (!$pendingAuth) {+ throw ValidationException::withMessages([+ 'pending_auth_token' => ['Invalid or expired verification session. Please log in again.'],+ ]);+ }++ // Get user+ $user = \App\Models\User::find($pendingAuth['user_id']);++ if (!$user) {+ throw ValidationException::withMessages([+ 'pending_auth_token' => ['User not found. Please log in again.'],+ ]);+ }++ // Verify code (TOTP or recovery code - validateTwoFactorCode handles both automatically)+ if (!$user->validateTwoFactorCode($request->code)) {+ throw ValidationException::withMessages([+ 'code' => ['Invalid verification code. Please try again.'],+ ]);+ }++ // Clear pending auth+ $this->twoFactorService->clearPendingAuth($request->pending_auth_token);++ // Issue JWT token+ $guard = auth('api');+ $token = $guard->login($user);++ // Set remember TTL if needed+ if ($pendingAuth['remember'] ?? false) {+ $guard->setTTL(config('jwt.remember_ttl'));+ $token = $guard->login($user); // Re-login with new TTL+ }++ $expiration = $guard->getPayload()->get('exp');++ return response()->json([+ 'token' => $token,+ 'token_type' => 'bearer',+ 'expires_in' => $expiration - time(),+ 'user' => $user,+ ]);+ }+}diff --git a/api/app/Http/Controllers/Settings/TwoFactorController.php b/api/app/Http/Controllers/Settings/TwoFactorController.phpnew file mode 100644index 000000000..6d6c38b51--- /dev/null+++ b/api/app/Http/Controllers/Settings/TwoFactorController.php@@ -0,0 +1,160 @@+<?php++namespace App\Http\Controllers\Settings;++use App\Http\Controllers\Controller;+use Illuminate\Http\Request;+use Illuminate\Support\Facades\Hash;+use Illuminate\Validation\ValidationException;++class TwoFactorController extends Controller+{+ /**+ * Enable 2FA and return QR code data.+ */+ public function enable(Request $request)+ {+ $user = $request->user();++ // Check if already enabled+ if ($user->hasTwoFactorEnabled()) {+ return response()->json([+ 'message' => 'Two-factor authentication is already enabled.',+ ], 400);+ }++ // Create 2FA secret and QR code+ $secret = $user->createTwoFactorAuth();++ return response()->json([+ 'qr_code' => $secret->toQr(),+ 'uri' => $secret->toUri(),+ 'secret' => $secret->toString(),+ ]);+ }++ /**+ * Confirm 2FA setup with verification code.+ */+ public function confirm(Request $request)+ {+ $request->validate([+ 'code' => 'required|string|size:6',+ ]);++ $user = $request->user();++ // Check if 2FA is already enabled (confirmed)+ if ($user->hasTwoFactorEnabled()) {+ return response()->json([+ 'message' => 'Two-factor authentication is already enabled.',+ ], 400);+ }++ // Confirm 2FA (this validates and enables automatically)+ if (!$user->confirmTwoFactorAuth($request->code)) {+ throw ValidationException::withMessages([+ 'code' => ['Invalid verification code. Please try again.'],+ ]);+ }++ return response()->json([+ 'message' => 'Two-factor authentication has been enabled successfully.',+ 'recovery_codes' => $user->getRecoveryCodes()->toArray(),+ ]);+ }++ /**+ * Disable 2FA (requires 2FA code or recovery code verification).+ */+ public function disable(Request $request)+ {+ $request->validate([+ 'code' => 'required|string|min:6|max:8', // Supports both TOTP (6) and recovery codes (8)+ ]);++ $user = $request->user();++ if (!$user->hasTwoFactorEnabled()) {+ return response()->json([+ 'message' => 'Two-factor authentication is not enabled.',+ ], 400);+ }++ // Verify code (TOTP or recovery code - validateTwoFactorCode handles both automatically)+ if (!$user->validateTwoFactorCode($request->code)) {+ throw ValidationException::withMessages([+ 'code' => ['Invalid verification code. Please try again.'],+ ]);+ }++ // Disable 2FA+ $user->disableTwoFactorAuth();++ return response()->json([+ 'message' => 'Two-factor authentication has been disabled successfully.',+ ]);+ }++ /**+ * Get recovery codes.+ * Requires password verification for security.+ */+ public function recoveryCodes(Request $request)+ {+ $request->validate([+ 'password' => 'required|string',+ ]);++ $user = $request->user();++ if (!$user->hasTwoFactorEnabled()) {+ return response()->json([+ 'message' => 'Two-factor authentication is not enabled.',+ ], 400);+ }++ // Verify password+ if (!Hash::check($request->password, $user->password)) {+ throw ValidationException::withMessages([+ 'password' => ['The password is incorrect.'],+ ]);+ }++ return response()->json([+ 'recovery_codes' => $user->getRecoveryCodes()->toArray(),+ ]);+ }++ /**+ * Regenerate recovery codes (requires 2FA code only - supports OAuth users without passwords).+ */+ public function regenerateRecoveryCodes(Request $request)+ {+ $request->validate([+ 'code' => 'required|string|min:6|max:8', // Supports both TOTP (6) and recovery codes (8)+ ]);++ $user = $request->user();++ if (!$user->hasTwoFactorEnabled()) {+ return response()->json([+ 'message' => 'Two-factor authentication is not enabled.',+ ], 400);+ }++ // Verify 2FA code (TOTP or recovery code)+ if (!$user->validateTwoFactorCode($request->code)) {+ throw ValidationException::withMessages([+ 'code' => ['Invalid verification code. Please try again.'],+ ]);+ }++ $user->generateRecoveryCodes();++ return response()->json([+ 'recovery_codes' => $user->getRecoveryCodes()->toArray(),+ 'message' => 'Recovery codes have been regenerated. Please save them in a safe place.',+ ]);+ }+}diff --git a/api/app/Http/Resources/UserResource.php b/api/app/Http/Resources/UserResource.phpindex 03371f3f1..ca25ac844 100644--- a/api/app/Http/Resources/UserResource.php+++ b/api/app/Http/Resources/UserResource.php@@ -3,6 +3,7 @@namespace App\Http\Resources;use Illuminate\Http\Resources\Json\JsonResource;+use Illuminate\Support\Facades\Auth;class UserResource extends JsonResource{@@ -14,7 +15,7 @@ class UserResource extends JsonResource*/public function toArray($request){- $personalData = \Auth::id() === $this->id ? [+ $personalData = Auth::id() === $this->id ? ['is_pro' => $this->is_pro,'is_subscribed' => $this->is_subscribed,'has_enterprise_subscription' => $this->has_enterprise_subscription,@@ -24,6 +25,7 @@ class UserResource extends JsonResource'has_customer_id' => $this->has_customer_id,'has_forms' => $this->has_forms,'active_license' => $this->licenses()->active()->first(),+ 'two_factor_enabled' => $this->hasTwoFactorEnabled(),] : [];return array_merge(parent::toArray($request), $personalData);diff --git a/api/app/Models/User.php b/api/app/Models/User.phpindex 92997f787..4ba914557 100644--- a/api/app/Models/User.php+++ b/api/app/Models/User.php@@ -11,17 +11,20 @@ use Illuminate\Database\Eloquent\Factories\HasFactory;use Illuminate\Foundation\Auth\User as Authenticatable;use Illuminate\Notifications\Notifiable;use Illuminate\Support\Facades\Hash;+use Laragear\TwoFactor\Contracts\TwoFactorAuthenticatable as TwoFactorAuthenticatableContract;+use Laragear\TwoFactor\TwoFactorAuthentication;use Laravel\Cashier\Billable;use Laravel\Sanctum\HasApiTokens;use Tymon\JWTAuth\Contracts\JWTSubject;-class User extends Authenticatable implements JWTSubject, CachableAttributes+class User extends Authenticatable implements JWTSubject, CachableAttributes, TwoFactorAuthenticatableContract{use Billable;use HasFactory;use Notifiable;use HasApiTokens;use CachesAttributes;+ use TwoFactorAuthentication;public const ROLE_ADMIN = 'admin';public const ROLE_USER = 'user';diff --git a/api/app/Service/Auth/TwoFactorAuthService.php b/api/app/Service/Auth/TwoFactorAuthService.phpnew file mode 100644index 000000000..5117fa148--- /dev/null+++ b/api/app/Service/Auth/TwoFactorAuthService.php@@ -0,0 +1,52 @@+<?php++namespace App\Service\Auth;++use App\Models\User;+use Illuminate\Support\Facades\Cache;+use Illuminate\Support\Str;++class TwoFactorAuthService+{+ /**+ * Check if user requires 2FA verification.+ */+ public function requiresVerification(User $user): bool+ {+ return $user->hasTwoFactorEnabled();+ }++ /**+ * Store pending authentication and return token.+ */+ public function storePendingAuth(User $user, array $context = []): string+ {+ $token = Str::random(64);++ Cache::put("2fa_pending:{$token}", [+ 'user_id' => $user->id,+ 'method' => $context['method'] ?? 'password',+ 'remember' => $context['remember'] ?? false,+ 'created_at' => now()->toIso8601String(),+ 'context' => $context,+ ], now()->addMinutes(10));++ return $token;+ }++ /**+ * Get pending authentication data.+ */+ public function getPendingAuth(string $token): ?array+ {+ return Cache::get("2fa_pending:{$token}");+ }++ /**+ * Clear pending authentication.+ */+ public function clearPendingAuth(string $token): void+ {+ Cache::forget("2fa_pending:{$token}");+ }+}diff --git a/api/app/Service/OAuth/OAuthFlowOrchestrator.php b/api/app/Service/OAuth/OAuthFlowOrchestrator.phpindex 57ecfe004..8b0d7f88c 100644--- a/api/app/Service/OAuth/OAuthFlowOrchestrator.php+++ b/api/app/Service/OAuth/OAuthFlowOrchestrator.php@@ -6,6 +6,7 @@ use App\Http\Controllers\Auth\Traits\ManagesJWT;use App\Http\Resources\OAuthProviderResource;use App\Integrations\OAuth\OAuthProviderService;use App\Service\OAuth\OAuthProviderService as OAuthProviderServiceClass;+use Illuminate\Http\JsonResponse;use Illuminate\Http\Request;use Illuminate\Support\Facades\Auth;@@ -101,12 +102,12 @@ class OAuthFlowOrchestrator* Process OAuth callback* Retrieves context from state token and creates/authenticates user*/- public function processCallback(string $provider, array $params): array+ public function processCallback(string $provider, array $params): JsonResponse{try {$providerService = OAuthProviderService::from($provider);} catch (\ValueError $e) {- abort(400, "Invalid OAuth provider: {$provider}");+ return response()->json(['error' => "Invalid OAuth provider: {$provider}"], 400);}// Get user data from OAuth provider@@ -117,7 +118,7 @@ class OAuthFlowOrchestrator$context = $this->contextService->getContext($stateToken);if (!$context) {- abort(419, 'OAuth context expired or invalid state');+ return response()->json(['error' => 'OAuth context expired or invalid state'], 419);}$intent = $context['intent'];@@ -135,18 +136,22 @@ class OAuthFlowOrchestrator* Handles widget flows (Google One Tap) that don't use state tokens* Extracts and stores context for user creation*/- public function processWidgetCallback(string $service, Request $request): array+ public function processWidgetCallback(string $service, Request $request): JsonResponse{try {$providerService = OAuthProviderService::from($service);} catch (\ValueError $e) {- abort(400, "Invalid OAuth provider: {$service}");+ return response()->json(['error' => "Invalid OAuth provider: {$service}"], 400);}$intent = $request->input('intent');$inviteToken = $request->input('invite_token');// Validate intent requirements- $this->validateIntentRequirements($intent, $providerService);+ try {+ $this->validateIntentRequirements($intent, $providerService);+ } catch (\Symfony\Component\HttpKernel\Exception\HttpException $e) {+ return response()->json(['error' => $e->getMessage()], $e->getStatusCode());+ }// Handle invite validation for auth flows$invitedEmail = null;@@ -181,7 +186,7 @@ class OAuthFlowOrchestratorarray $userData,?string $inviteToken = null,?string $invitedEmail = null- ): array {+ ): JsonResponse {return match ($intent) {self::INTENT_AUTH => $this->handleAuthenticationFlow($providerService,@@ -193,7 +198,7 @@ class OAuthFlowOrchestrator$providerService,$userData),- default => abort(400, 'Invalid intent')+ default => response()->json(['error' => 'Invalid intent'], 400)};}@@ -206,9 +211,13 @@ class OAuthFlowOrchestratorarray $userData,?string $inviteToken = null,?string $invitedEmail = null- ): array {+ ): JsonResponse {// Generic email validation (no provider-specific logic)- $this->inviteService->validateEmailRestrictions($userData['email'], $invitedEmail);+ try {+ $this->inviteService->validateEmailRestrictions($userData['email'], $invitedEmail);+ } catch (\Symfony\Component\HttpKernel\Exception\HttpException $e) {+ return response()->json(['error' => $e->getMessage()], $e->getStatusCode());+ }// Find or create user$user = $this->oauthUserService->findOrCreateUser($userData, $providerService, $inviteToken);@@ -216,18 +225,20 @@ class OAuthFlowOrchestrator// Create/update OAuth provider record$this->oauthProviderService->createOrUpdateProvider($user, $providerService, $userData);- // Return JWT token for authentication- $response = $this->sendLoginResponse($user);- return $response->getData(true);+ // sendLoginResponse() automatically handles 2FA check and blocked user check+ return $this->sendLoginResponse($user, [+ 'method' => 'oauth',+ 'provider' => $providerService->value,+ ]);}/*** Handle integration flow (connect OAuth provider to existing user)*/- private function handleIntegrationFlow(OAuthProviderService $providerService, array $userData): array+ private function handleIntegrationFlow(OAuthProviderService $providerService, array $userData): JsonResponse{if (!Auth::check()) {- abort(401, 'Authentication required for integration connections');+ return response()->json(['error' => 'Authentication required for integration connections'], 401);}/** @var \App\Models\User $user */@@ -243,11 +254,11 @@ class OAuthFlowOrchestrator// Retrieve context data (autoClose and intention from stored context)$context = $this->contextService->getContext() ?? [];- return [+ return response()->json(['provider' => OAuthProviderResource::make($oauthProvider),'autoClose' => $context['autoClose'] ?? false,'intention' => $context['intention'] ?? null,- ];+ ]);}/**diff --git a/api/composer.json b/api/composer.jsonindex 0e6eebb8b..746083e7d 100644--- a/api/composer.json+++ b/api/composer.json@@ -21,6 +21,7 @@"google/apiclient": "^2.16","guzzlehttp/guzzle": "*","jolicode/slack-php-api": "^4.8",+ "laragear/two-factor": "^3.0","laravel/cashier": "*","laravel/framework": "^11.9","laravel/horizon": "*",diff --git a/api/composer.lock b/api/composer.lockindex fd0bfb916..becc6b739 100644--- a/api/composer.lock+++ b/api/composer.lock@@ -4,7 +4,7 @@"Read more about it at https://getcomposer.org/doc/01-basic-usage.md#installing-dependencies","This file is @generated automatically"],- "content-hash": "90f992fd8c24c322f10d2956290994a2",+ "content-hash": "6b6dbb0ec88dc87e23250fe5e6653c63","packages": [{"name": "aws/aws-crt-php",@@ -157,6 +157,61 @@},"time": "2025-11-12T19:18:02+00:00"},+ {+ "name": "bacon/bacon-qr-code",+ "version": "v3.0.3",+ "source": {+ "type": "git",+ "url": "https://github.com/Bacon/BaconQrCode.git",+ "reference": "36a1cb2b81493fa5b82e50bf8068bf84d1542563"+ },+ "dist": {+ "type": "zip",+ "url": "https://api.github.com/repos/Bacon/BaconQrCode/zipball/36a1cb2b81493fa5b82e50bf8068bf84d1542563",+ "reference": "36a1cb2b81493fa5b82e50bf8068bf84d1542563",+ "shasum": ""+ },+ "require": {+ "dasprid/enum": "^1.0.3",+ "ext-iconv": "*",+ "php": "^8.1"+ },+ "require-dev": {+ "phly/keep-a-changelog": "^2.12",+ "phpunit/phpunit": "^10.5.11 || ^11.0.4",+ "spatie/phpunit-snapshot-assertions": "^5.1.5",+ "spatie/pixelmatch-php": "^1.2.0",+ "squizlabs/php_codesniffer": "^3.9"+ },+ "suggest": {+ "ext-imagick": "to generate QR code images"+ },+ "type": "library",+ "autoload": {+ "psr-4": {+ "BaconQrCode\\": "src/"+ }+ },+ "notification-url": "https://packagist.org/downloads/",+ "license": [+ "BSD-2-Clause"+ ],+ "authors": [+ {+ "name": "Ben Scholzen 'DASPRiD'",+ "email": "[email protected]",+ "homepage": "https://dasprids.de/",+ "role": "Developer"+ }+ ],+ "description": "BaconQrCode is a QR code generator for PHP.",+ "homepage": "https://github.com/Bacon/BaconQrCode",+ "support": {+ "issues": "https://github.com/Bacon/BaconQrCode/issues",+ "source": "https://github.com/Bacon/BaconQrCode/tree/v3.0.3"+ },+ "time": "2025-11-19T17:15:36+00:00"+ },{"name": "brick/math","version": "0.14.0",@@ -508,6 +563,56 @@],"time": "2025-08-20T19:15:30+00:00"},+ {+ "name": "dasprid/enum",+ "version": "1.0.7",+ "source": {+ "type": "git",+ "url": "https://github.com/DASPRiD/Enum.git",+ "reference": "b5874fa9ed0043116c72162ec7f4fb50e02e7cce"+ },+ "dist": {+ "type": "zip",+ "url": "https://api.github.com/repos/DASPRiD/Enum/zipball/b5874fa9ed0043116c72162ec7f4fb50e02e7cce",+ "reference": "b5874fa9ed0043116c72162ec7f4fb50e02e7cce",+ "shasum": ""+ },+ "require": {+ "php": ">=7.1 <9.0"+ },+ "require-dev": {+ "phpunit/phpunit": "^7 || ^8 || ^9 || ^10 || ^11",+ "squizlabs/php_codesniffer": "*"+ },+ "type": "library",+ "autoload": {+ "psr-4": {+ "DASPRiD\\Enum\\": "src/"+ }+ },+ "notification-url": "https://packagist.org/downloads/",+ "license": [+ "BSD-2-Clause"+ ],+ "authors": [+ {+ "name": "Ben Scholzen 'DASPRiD'",+ "email": "[email protected]",+ "homepage": "https://dasprids.de/",+ "role": "Developer"+ }+ ],+ "description": "PHP 7.1 enum implementation",+ "keywords": [+ "enum",+ "map"+ ],+ "support": {+ "issues": "https://github.com/DASPRiD/Enum/issues",+ "source": "https://github.com/DASPRiD/Enum/tree/1.0.7"+ },+ "time": "2025-09-16T12:23:56+00:00"+ },{"name": "dflydev/dot-access-data","version": "v3.0.3",@@ -2520,6 +2625,211 @@},"time": "2025-04-01T15:55:35+00:00"},+ {+ "name": "laragear/meta",+ "version": "v3.1.2",+ "source": {+ "type": "git",+ "url": "https://github.com/Laragear/Meta.git",+ "reference": "f204694aa232f56cfada912c56fb14e9ff643fcd"+ },+ "dist": {+ "type": "zip",+ "url": "https://api.github.com/repos/Laragear/Meta/zipball/f204694aa232f56cfada912c56fb14e9ff643fcd",+ "reference": "f204694aa232f56cfada912c56fb14e9ff643fcd",+ "shasum": ""+ },+ "require": {+ "php": "^8.1"+ },+ "require-dev": {+ "laragear/meta-testing": "2.*",+ "laravel/breeze": "1.*|2.*",+ "orchestra/testbench": "8.*|9.*"+ },+ "type": "library",+ "autoload": {+ "psr-4": {+ "Laragear\\Meta\\": "src"+ }+ },+ "notification-url": "https://packagist.org/downloads/",+ "license": [+ "MIT"+ ],+ "authors": [+ {+ "name": "Italo Israel Baeza Cabrera",+ "email": "[email protected]",+ "homepage": "https://github.com/sponsors/DarkGhostHunter"+ }+ ],+ "description": "A Laravel Package helper for Laravel Packages",+ "keywords": [+ "laravel",+ "package"+ ],+ "support": {+ "issues": "https://github.com/Laragear/Meta/issues",+ "source": "https://github.com/Laragear/Meta"+ },+ "funding": [+ {+ "url": "https://github.com/sponsors/DarkGhostHunter",+ "type": "Github Sponsorship"+ },+ {+ "url": "https://paypal.me/darkghosthunter",+ "type": "Paypal"+ }+ ],+ "time": "2025-01-29T00:29:43+00:00"+ },+ {+ "name": "laragear/meta-model",+ "version": "v2.0.0",+ "source": {+ "type": "git",+ "url": "https://github.com/Laragear/MetaModel.git",+ "reference": "1973517263d9ff1cfaabf682f3c2883425271dbc"+ },+ "dist": {+ "type": "zip",+ "url": "https://api.github.com/repos/Laragear/MetaModel/zipball/1973517263d9ff1cfaabf682f3c2883425271dbc",+ "reference": "1973517263d9ff1cfaabf682f3c2883425271dbc",+ "shasum": ""+ },+ "require": {+ "illuminate/container": "11.*|12.*",+ "illuminate/contracts": "11.*|12.*",+ "illuminate/database": "11.*|12.*",+ "php": "^8.2"+ },+ "require-dev": {+ "mockery/mockery": "^1.6",+ "phpunit/phpunit": "11.*|12.*"+ },+ "type": "library",+ "autoload": {+ "psr-4": {+ "Laragear\\MetaModel\\": "src"+ }+ },+ "notification-url": "https://packagist.org/downloads/",+ "license": [+ "MIT"+ ],+ "authors": [+ {+ "name": "Italo Israel Baeza Cabrera",+ "email": "[email protected]",+ "homepage": "https://github.com/sponsors/DarkGhostHunter",+ "role": "Developer"+ }+ ],+ "description": "Let other developers customize your package model and migrations",+ "keywords": [+ "database",+ "eloquent",+ "laravel",+ "model"+ ],+ "support": {+ "issues": "https://github.com/Laragear/MetaModel/issues",+ "source": "https://github.com/Laragear/MetaModel"+ },+ "funding": [+ {+ "url": "https://github.com/sponsors/DarkGhostHunter",+ "type": "Github Sponsorship"+ },+ {+ "url": "https://paypal.me/darkghosthunter",+ "type": "Paypal"+ }+ ],+ "time": "2025-02-16T04:19:25+00:00"+ },+ {+ "name": "laragear/two-factor",+ "version": "v3.0.0",+ "source": {+ "type": "git",+ "url": "https://github.com/Laragear/TwoFactor.git",+ "reference": "e895ce4f8eb96fa813e687a4138e6f88ac109748"+ },+ "dist": {+ "type": "zip",+ "url": "https://api.github.com/repos/Laragear/TwoFactor/zipball/e895ce4f8eb96fa813e687a4138e6f88ac109748",+ "reference": "e895ce4f8eb96fa813e687a4138e6f88ac109748",+ "shasum": ""+ },+ "require": {+ "bacon/bacon-qr-code": "3.*",+ "ext-json": "*",+ "illuminate/auth": "11.*|12.*",+ "illuminate/config": "11.*|12.*",+ "illuminate/database": "11.*|12.*",+ "illuminate/http": "11.*|12.*",+ "illuminate/support": "11.*|12.*",+ "illuminate/validation": "11.*|12.*",+ "laragear/meta": "3.*",+ "laragear/meta-model": "2.*",+ "paragonie/constant_time_encoding": "3.*",+ "php": "^8.2"+ },+ "require-dev": {+ "laragear/meta-testing": "2.*",+ "orchestra/testbench": "9.*|10.*"+ },+ "type": "library",+ "extra": {+ "laravel": {+ "providers": [+ "Laragear\\TwoFactor\\TwoFactorServiceProvider"+ ]+ }+ },+ "autoload": {+ "psr-4": {+ "Laragear\\TwoFactor\\": "src",+ "Database\\Factories\\Laragear\\TwoFactor\\": "database/factories"+ }+ },+ "notification-url": "https://packagist.org/downloads/",+ "license": [+ "MIT"+ ],+ "authors": [+ {+ "name": "Italo Israel Baeza Cabrera",+ "email": "[email protected]",+ "homepage": "https://patreon.com/packagesforlaravel"+ }+ ],+ "description": "On-premises 2FA Authentication for out-of-the-box.",+ "keywords": [+ "2fa",+ "Authentication",+ "laravel",+ "two-factor"+ ],+ "support": {+ "issues": "https://github.com/Laragear/TwoFactor/issues",+ "source": "https://github.com/Laragear/TwoFactor"+ },+ "funding": [+ {+ "url": "https://github.com/sponsors/DarkGhostHunter",+ "type": "Github Sponsorship"+ },+ {+ "url": "https://paypal.me/darkghosthunter",+ "type": "Paypal"+ }+ ],+ "time": "2025-02-16T19:29:26+00:00"+ },{"name": "laravel/cashier","version": "v16.0.5",diff --git a/api/database/migrations/2025_11_18_160000_create_two_factor_authentications_table.php b/api/database/migrations/2025_11_18_160000_create_two_factor_authentications_table.phpnew file mode 100644index 000000000..53fbcc950--- /dev/null+++ b/api/database/migrations/2025_11_18_160000_create_two_factor_authentications_table.php@@ -0,0 +1,10 @@+<?php++use Illuminate\Database\Schema\Blueprint;+use Laragear\TwoFactor\Models\TwoFactorAuthentication;++return TwoFactorAuthentication::migration()->with(function (Blueprint $table) {+ // Here you can add custom columns to the Two Factor table.+ //+ // $table->string('alias')->nullable();+});diff --git a/api/routes/api.php b/api/routes/api.phpindex b8e71a91f..5f1deae0a 100644--- a/api/routes/api.php+++ b/api/routes/api.php@@ -68,6 +68,14 @@ Route::group(['middleware' => 'auth.multi'], function () {Route::prefix('/providers')->name('providers.')->group(function () {Route::delete('/{provider}', [OAuthProviderController::class, 'destroy'])->name('destroy');});++ Route::prefix('/two-factor')->name('two-factor.')->group(function () {+ Route::post('/enable', [\App\Http\Controllers\Settings\TwoFactorController::class, 'enable'])->name('enable');+ Route::post('/confirm', [\App\Http\Controllers\Settings\TwoFactorController::class, 'confirm'])->name('confirm');+ Route::post('/disable', [\App\Http\Controllers\Settings\TwoFactorController::class, 'disable'])->name('disable');+ Route::post('/recovery-codes', [\App\Http\Controllers\Settings\TwoFactorController::class, 'recoveryCodes'])->name('recovery-codes');+ Route::post('/recovery-codes/regenerate', [\App\Http\Controllers\Settings\TwoFactorController::class, 'regenerateRecoveryCodes'])->name('recovery-codes.regenerate');+ });});Route::prefix('subscription')->name('subscription.')->group(function () {@@ -300,6 +308,9 @@ Route::group(['middleware' => 'guest:api'], function () {// OIDC email lookup endpoint (for login flow)Route::post('auth/oidc/options', [\App\Http\Controllers\Auth\SsoController::class, 'getOptionsForEmail'])->name('sso.options');++ // Two-factor authentication verification (public, but requires pending auth token)+ Route::post('/auth/two-factor/verify', [\App\Http\Controllers\Auth\TwoFactorVerificationController::class, 'verify'])->name('two-factor.verify');});Route::group(['prefix' => 'appsumo'], function () {diff --git a/api/tests/Feature/LoginTest.php b/api/tests/Feature/LoginTest.phpindex 6ffc6e393..dff532f4e 100644--- a/api/tests/Feature/LoginTest.php+++ b/api/tests/Feature/LoginTest.php@@ -45,8 +45,8 @@ it('cannot login if user is blocked', function () {'email' => $user->email,'password' => 'Abcd@1234',])- ->assertStatus(422)- ->assertJsonValidationErrors(['email' => 'Your account has been blocked. Please contact support.']);+ ->assertStatus(403)+ ->assertJson(['message' => 'Your account has been blocked. Please contact support.']);$this->assertGuest();});diff --git a/api/tests/Feature/TwoFactorTest.php b/api/tests/Feature/TwoFactorTest.phpnew file mode 100644index 000000000..3a2ed013c--- /dev/null+++ b/api/tests/Feature/TwoFactorTest.php@@ -0,0 +1,1094 @@+<?php++use App\Models\User;+use Illuminate\Support\Facades\Cache;+use Illuminate\Support\Facades\RateLimiter;++uses()->group('two-factor', 'feature');++beforeEach(function () {+ // Clear cache before each test+ Cache::flush();+});++describe('TwoFactorController - Enable', function () {+ it('can enable 2FA and get QR code', function () {+ $user = User::factory()->create();++ $response = $this->actingAs($user, 'api')+ ->postJson('/settings/two-factor/enable')+ ->assertSuccessful()+ ->assertJsonStructure([+ 'qr_code',+ 'uri',+ 'secret',+ ]);++ expect($user->fresh()->hasTwoFactorEnabled())->toBeFalse(); // Not confirmed yet+ expect($response->json('secret'))->toBeString();+ expect($response->json('qr_code'))->toBeString();+ });++ it('cannot enable 2FA if already enabled', function () {+ $user = User::factory()->create();+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ $response = $this->actingAs($user, 'api')+ ->postJson('/settings/two-factor/enable')+ ->assertStatus(400)+ ->assertJson([+ 'message' => 'Two-factor authentication is already enabled.',+ ]);+ });++ it('requires authentication to enable 2FA', function () {+ $this->postJson(route('settings.two-factor.enable'))+ ->assertUnauthorized();+ });+});++describe('TwoFactorController - Confirm', function () {+ it('can confirm 2FA setup with valid code', function () {+ $user = User::factory()->create();+ $secret = $user->createTwoFactorAuth();++ // Generate a valid TOTP code+ $code = $secret->makeCode();++ $response = $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.confirm'), [+ 'code' => $code,+ ])+ ->assertSuccessful()+ ->assertJsonStructure([+ 'message',+ 'recovery_codes',+ ]);++ expect($user->fresh()->hasTwoFactorEnabled())->toBeTrue();+ expect($response->json('recovery_codes'))->toBeArray();+ expect(count($response->json('recovery_codes')))->toBeGreaterThan(0);+ });++ it('cannot confirm with invalid code', function () {+ $user = User::factory()->create();+ $user->createTwoFactorAuth();++ $response = $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.confirm'), [+ 'code' => '000000',+ ])+ ->assertStatus(422)+ ->assertJsonValidationErrors(['code']);++ expect($user->fresh()->hasTwoFactorEnabled())->toBeFalse();+ });++ it('requires valid code format', function () {+ $user = User::factory()->create();+ $user->createTwoFactorAuth();++ $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.confirm'), [+ 'code' => '12345', // Too short+ ])+ ->assertStatus(422)+ ->assertJsonValidationErrors(['code']);+ });++ it('cannot confirm if already confirmed', function () {+ $user = User::factory()->create();+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ // Refresh user to get updated state+ $user = $user->fresh();++ // Verify 2FA is enabled+ expect($user->hasTwoFactorEnabled())->toBeTrue();++ // Try to confirm again with a new code - should fail+ $newCode = $secret->makeCode();+ $response = $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.confirm'), [+ 'code' => $newCode,+ ]);++ // The controller should detect that 2FA is already confirmed+ // If it returns 200, it means the check isn't working - let's debug+ if ($response->status() === 200) {+ // Check what the actual response is+ dump($response->json());+ expect($response->status())->toBe(400);+ }++ $response->assertStatus(400)+ ->assertJson([+ 'message' => 'Two-factor authentication is already enabled.',+ ]);+ });+});++describe('TwoFactorController - Disable', function () {+ it('can disable 2FA with valid TOTP code', function () {+ $user = User::factory()->create();+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ expect($user->fresh()->hasTwoFactorEnabled())->toBeTrue();++ // Generate a fresh code for disabling (TOTP codes are time-based)+ $disableCode = $secret->makeCode();++ // If code validation fails, try with a small time offset+ $response = $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.disable'), [+ 'code' => $disableCode,+ ]);++ // If it fails, try with offset codes (previous/next time window)+ if ($response->status() === 422) {+ $codeWithOffset = $secret->makeCode(now(), -1); // Previous window+ $response = $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.disable'), [+ 'code' => $codeWithOffset,+ ]);+ }++ $response->assertSuccessful()+ ->assertJson([+ 'message' => 'Two-factor authentication has been disabled successfully.',+ ]);++ expect($user->fresh()->hasTwoFactorEnabled())->toBeFalse();+ });++ it('can disable 2FA with recovery code', function () {+ $user = User::factory()->create();+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ $recoveryCodes = $user->getRecoveryCodes();+ $recoveryCode = $recoveryCodes->first();++ // Recovery codes can be arrays with 'code' key or strings+ $codeValue = is_string($recoveryCode) ? $recoveryCode : (is_array($recoveryCode) ? $recoveryCode['code'] : $recoveryCode->code ?? $recoveryCode);++ $response = $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.disable'), [+ 'code' => $codeValue,+ ])+ ->assertSuccessful();++ expect($user->fresh()->hasTwoFactorEnabled())->toBeFalse();+ });++ it('cannot disable 2FA with invalid code', function () {+ $user = User::factory()->create();+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.disable'), [+ 'code' => '000000',+ ])+ ->assertStatus(422)+ ->assertJsonValidationErrors(['code']);++ expect($user->fresh()->hasTwoFactorEnabled())->toBeTrue();+ });++ it('cannot disable if 2FA is not enabled', function () {+ $user = User::factory()->create();++ $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.disable'), [+ 'code' => '123456',+ ])+ ->assertStatus(400)+ ->assertJson([+ 'message' => 'Two-factor authentication is not enabled.',+ ]);+ });+});++describe('TwoFactorController - Recovery Codes', function () {+ it('can get recovery codes with valid password', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ $response = $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.recovery-codes'), [+ 'password' => 'password123',+ ])+ ->assertSuccessful()+ ->assertJsonStructure([+ 'recovery_codes',+ ]);++ expect($response->json('recovery_codes'))->toBeArray();+ expect(count($response->json('recovery_codes')))->toBeGreaterThan(0);+ });++ it('cannot get recovery codes with invalid password', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.recovery-codes'), [+ 'password' => 'wrongpassword',+ ])+ ->assertStatus(422)+ ->assertJsonValidationErrors(['password']);+ });++ it('cannot get recovery codes if 2FA is not enabled', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);++ $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.recovery-codes'), [+ 'password' => 'password123',+ ])+ ->assertStatus(400)+ ->assertJson([+ 'message' => 'Two-factor authentication is not enabled.',+ ]);+ });+});++describe('TwoFactorController - Regenerate Recovery Codes', function () {+ it('can regenerate recovery codes with valid TOTP code', function () {+ $user = User::factory()->create();+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ $oldCodes = $user->getRecoveryCodes();+ // Use recovery code for regeneration to avoid TOTP timing issues+ $recoveryCode = $oldCodes->first();+ $codeValue = is_string($recoveryCode) ? $recoveryCode : (is_array($recoveryCode) ? $recoveryCode['code'] : $recoveryCode->code ?? $recoveryCode);++ $response = $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.recovery-codes.regenerate'), [+ 'code' => $codeValue,+ ])+ ->assertSuccessful()+ ->assertJsonStructure([+ 'recovery_codes',+ 'message',+ ]);++ $newCodes = $response->json('recovery_codes');+ expect($newCodes)->toBeArray();+ expect(count($newCodes))->toBeGreaterThan(0);++ // New codes should be different from old ones+ $oldCodeStrings = $oldCodes->map(fn ($code) => is_string($code) ? $code : (is_array($code) ? $code['code'] : $code->code ?? $code))->toArray();+ $newCodeStrings = collect($newCodes)->map(fn ($code) => is_string($code) ? $code : (is_array($code) ? $code['code'] : $code->code ?? $code))->toArray();++ expect(array_intersect($oldCodeStrings, $newCodeStrings))->toBeEmpty();+ });++ it('can regenerate recovery codes with recovery code', function () {+ $user = User::factory()->create();+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ $recoveryCodes = $user->getRecoveryCodes();+ $recoveryCode = $recoveryCodes->first();+ $codeValue = is_string($recoveryCode) ? $recoveryCode : (is_array($recoveryCode) ? $recoveryCode['code'] : $recoveryCode->code ?? $recoveryCode);++ $response = $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.recovery-codes.regenerate'), [+ 'code' => $codeValue,+ ])+ ->assertSuccessful();++ expect($response->json('recovery_codes'))->toBeArray();+ });++ it('cannot regenerate with invalid code', function () {+ $user = User::factory()->create();+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.recovery-codes.regenerate'), [+ 'code' => '000000',+ ])+ ->assertStatus(422)+ ->assertJsonValidationErrors(['code']);+ });++ it('cannot regenerate if 2FA is not enabled', function () {+ $user = User::factory()->create();++ $this->actingAs($user, 'api')+ ->postJson(route('settings.two-factor.recovery-codes.regenerate'), [+ 'code' => '123456',+ ])+ ->assertStatus(400)+ ->assertJson([+ 'message' => 'Two-factor authentication is not enabled.',+ ]);+ });+});++describe('TwoFactorVerificationController - Verify', function () {+ it('can verify 2FA code during login and get JWT token', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ // Simulate login attempt that requires 2FA+ $loginResponse = $this->postJson(route('login'), [+ 'email' => $user->email,+ 'password' => 'password123',+ ]);++ expect($loginResponse->status())->toBe(422);+ expect($loginResponse->json('requires_2fa'))->toBeTrue();++ $pendingAuthToken = $loginResponse->json('pending_auth_token');+ expect($pendingAuthToken)->toBeString();++ // Note: ManagesJWT trait logs out the user when 2FA is required+ // Get recovery codes - need to temporarily authenticate since getRecoveryCodes() may need auth context+ $user = $user->fresh();+ auth('api')->login($user);+ $recoveryCodes = $user->getRecoveryCodes();+ auth('api')->logout();++ // Verify 2FA code - use recovery code for more reliable testing (TOTP codes are time-sensitive)+ // Get the first unused recovery code+ $recoveryCode = $recoveryCodes->first(function ($code) {+ $usedAt = is_array($code) ? ($code['used_at'] ?? null) : ($code->used_at ?? null);+ return $usedAt === null;+ });++ expect($recoveryCode)->not->toBeNull('Recovery code should be available');++ $codeValue = is_string($recoveryCode) ? $recoveryCode : (is_array($recoveryCode) ? $recoveryCode['code'] : $recoveryCode->code ?? $recoveryCode);++ // Ensure code value is a string+ expect($codeValue)->toBeString();+ expect(strlen($codeValue))->toBeGreaterThan(0);++ $response = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $pendingAuthToken,+ 'code' => $codeValue,+ ]);++ if ($response->status() !== 200) {+ $responseData = $response->json();+ // Check if it's a validation error+ if (isset($responseData['errors']['code'])) {+ // Code validation failed - this shouldn't happen with a valid recovery code+ expect($response->status())->toBe(200);+ }+ }++ $response->assertSuccessful();++ if ($response->status() !== 200) {+ $responseData = $response->json();+ // Check if it's a validation error+ if (isset($responseData['errors']['code'])) {+ // Code validation failed - this shouldn't happen with a valid recovery code+ expect($response->status())->toBe(200);+ }+ }++ $response->assertSuccessful()+ ->assertJsonStructure([+ 'token',+ 'token_type',+ 'expires_in',+ 'user',+ ]);++ expect($response->json('token_type'))->toBe('bearer');+ expect($response->json('user.id'))->toBe($user->id);+ });++ it('can verify with recovery code during login', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ // Simulate login attempt+ $loginResponse = $this->postJson(route('login'), [+ 'email' => $user->email,+ 'password' => 'password123',+ ]);++ $pendingAuthToken = $loginResponse->json('pending_auth_token');++ // Note: ManagesJWT trait logs out when 2FA is required+ // Get recovery codes - need to temporarily authenticate+ $user = $user->fresh();+ auth('api')->login($user);+ $recoveryCodes = $user->getRecoveryCodes();+ auth('api')->logout();+ // Get the first unused recovery code+ $recoveryCode = $recoveryCodes->first(function ($code) {+ $usedAt = is_array($code) ? ($code['used_at'] ?? null) : ($code->used_at ?? null);+ return $usedAt === null;+ });++ expect($recoveryCode)->not->toBeNull('Recovery code should be available');++ $codeValue = is_string($recoveryCode) ? $recoveryCode : (is_array($recoveryCode) ? $recoveryCode['code'] : $recoveryCode->code ?? $recoveryCode);++ $response = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $pendingAuthToken,+ 'code' => $codeValue,+ ]);++ $response->assertSuccessful()+ ->assertJsonStructure(['token']);+ });++ it('cannot verify with invalid code', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ // Simulate login attempt+ $loginResponse = $this->postJson(route('login'), [+ 'email' => $user->email,+ 'password' => 'password123',+ ]);++ $pendingAuthToken = $loginResponse->json('pending_auth_token');++ // Note: ManagesJWT trait logs out when 2FA is required, so user should already be logged out++ // Try with invalid code+ $response = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $pendingAuthToken,+ 'code' => '000000',+ ]);++ // Invalid code returns 422 with validation error (ValidationException)+ expect($response->status())->toBe(422);+ // ValidationException returns errors in 'errors' key+ $responseData = $response->json();+ expect($responseData)->toHaveKey('errors');+ expect($responseData['errors'])->toHaveKey('code');+ });++ it('cannot verify with expired pending auth token', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ // Create expired token manually+ $expiredToken = 'expired_token_' . uniqid();+ Cache::put("2fa_pending:{$expiredToken}", [+ 'user_id' => $user->id,+ 'method' => 'password',+ 'created_at' => now()->subMinutes(15)->toIso8601String(),+ ], now()->subMinutes(10)); // Already expired++ $verifyCode = $secret->makeCode();+ $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $expiredToken,+ 'code' => $verifyCode,+ ])+ ->assertStatus(422)+ ->assertJsonValidationErrors(['pending_auth_token']);+ });++ it('cannot verify with invalid pending auth token', function () {+ $user = User::factory()->create();+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ $verifyCode = $secret->makeCode();+ $response = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => 'invalid_token',+ 'code' => $verifyCode,+ ]);++ // Invalid token should return 422 with validation error+ expect($response->status())->toBe(422);+ expect($response->json('errors.pending_auth_token'))->toBeArray();+ });++ it('respects rate limiting for verification attempts', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ // Simulate login attempt+ $loginResponse = $this->postJson(route('login'), [+ 'email' => $user->email,+ 'password' => 'password123',+ ]);++ $pendingAuthToken = $loginResponse->json('pending_auth_token');++ // Make 5 failed attempts (should return 422 for validation errors)+ for ($i = 0; $i < 5; $i++) {+ $response = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $pendingAuthToken,+ 'code' => '000000',+ ]);+ // Should return 422 for invalid code+ expect($response->status())->toBe(422);+ }++ // 6th attempt should be rate limited (422 with rate limit message)+ $response = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $pendingAuthToken,+ 'code' => '000000',+ ]);++ // After 5 failed attempts, the 6th should be rate limited (422)+ expect($response->status())->toBe(422);+ // Should have validation errors with rate limit message+ $responseData = $response->json();+ expect($responseData)->toHaveKey('errors');+ expect($responseData['errors'])->toHaveKey('code');+ });++ it('rate limiting is per pending_auth_token not per IP', function () {+ $user1 = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret1 = $user1->createTwoFactorAuth();+ $code1 = $secret1->makeCode();+ $user1->confirmTwoFactorAuth($code1);++ $user2 = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret2 = $user2->createTwoFactorAuth();+ $code2 = $secret2->makeCode();+ $user2->confirmTwoFactorAuth($code2);++ // Get pending tokens for both users+ $loginResponse1 = $this->postJson(route('login'), [+ 'email' => $user1->email,+ 'password' => 'password123',+ ]);+ $token1 = $loginResponse1->json('pending_auth_token');++ $loginResponse2 = $this->postJson(route('login'), [+ 'email' => $user2->email,+ 'password' => 'password123',+ ]);+ $token2 = $loginResponse2->json('pending_auth_token');++ // Make 5 failed attempts with token1+ for ($i = 0; $i < 5; $i++) {+ $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $token1,+ 'code' => '000000',+ ])->assertStatus(422);+ }++ // Token1 should now be rate limited+ $response1 = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $token1,+ 'code' => '000000',+ ]);+ expect($response1->status())->toBe(422);+ expect($response1->json('errors.code.0'))->toContain('Too many attempts');++ // Token2 should still work (not rate limited)+ $response2 = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $token2,+ 'code' => '000000',+ ]);+ // Should return 422 for invalid code, but NOT rate limited+ expect($response2->status())->toBe(422);+ expect($response2->json('errors.code.0'))->not->toContain('Too many attempts');+ });++ it('cannot verify with token that expired due to cache TTL', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ // Create a token and then manually expire it by deleting from cache+ // This simulates what happens when a token expires after 10 minutes+ $expiredToken = \Illuminate\Support\Str::random(64);++ // Put token in cache with very short TTL (1 second)+ Cache::put("2fa_pending:{$expiredToken}", [+ 'user_id' => $user->id,+ 'method' => 'password',+ 'remember' => false,+ 'created_at' => now()->subMinutes(15)->toIso8601String(),+ 'context' => [],+ ], now()->addSeconds(1));++ // Wait for cache to expire+ sleep(2);++ // Verify token is no longer in cache+ expect(Cache::get("2fa_pending:{$expiredToken}"))->toBeNull();++ $verifyCode = $secret->makeCode();+ $response = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $expiredToken,+ 'code' => $verifyCode,+ ]);++ // Should return 422 with validation error for expired/invalid token+ expect($response->status())->toBe(422);+ expect($response->json('errors.pending_auth_token'))->toBeArray();+ expect($response->json('errors.pending_auth_token.0'))->toContain('expired');+ });++ it('cannot verify with token that was manually cleared from cache', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ // Create a token normally+ $token = \Illuminate\Support\Str::random(64);+ Cache::put("2fa_pending:{$token}", [+ 'user_id' => $user->id,+ 'method' => 'password',+ 'remember' => false,+ 'created_at' => now()->toIso8601String(),+ 'context' => [],+ ], now()->addMinutes(10));++ // Manually clear it (simulating expiration or manual cleanup)+ Cache::forget("2fa_pending:{$token}");++ // Get recovery code for verification+ auth('api')->login($user);+ $recoveryCodes = $user->getRecoveryCodes();+ auth('api')->logout();+ $recoveryCode = $recoveryCodes->first(function ($code) {+ $usedAt = is_array($code) ? ($code['used_at'] ?? null) : ($code->used_at ?? null);+ return $usedAt === null;+ });+ $codeValue = is_string($recoveryCode) ? $recoveryCode : (is_array($recoveryCode) ? $recoveryCode['code'] : $recoveryCode->code ?? $recoveryCode);++ $response = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $token,+ 'code' => $codeValue,+ ]);++ // Should return 422 with validation error for expired/invalid token+ expect($response->status())->toBe(422);+ expect($response->json('errors.pending_auth_token'))->toBeArray();+ expect($response->json('errors.pending_auth_token.0'))->toContain('expired');+ });++ it('cannot verify with invalid code formats', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ // Simulate login attempt+ $loginResponse = $this->postJson(route('login'), [+ 'email' => $user->email,+ 'password' => 'password123',+ ]);++ $pendingAuthToken = $loginResponse->json('pending_auth_token');++ // Test various invalid code formats+ $invalidCodes = [+ '12345', // Too short (5 digits)+ '1234567', // Too long for TOTP (7 digits)+ '12345678', // Valid length but invalid format+ 'abcdef', // Non-numeric+ '12345a', // Mixed alphanumeric+ '', // Empty string+ ];++ foreach ($invalidCodes as $invalidCode) {+ $response = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $pendingAuthToken,+ 'code' => $invalidCode,+ ]);++ // Should return 422 with validation error+ expect($response->status())->toBe(422);+ expect($response->json('errors.code'))->toBeArray();+ }+ });++ it('cannot verify with code that is too short or too long', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ // Simulate login attempt+ $loginResponse = $this->postJson(route('login'), [+ 'email' => $user->email,+ 'password' => 'password123',+ ]);++ $pendingAuthToken = $loginResponse->json('pending_auth_token');++ // Test code that is too short (less than 6)+ $response = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $pendingAuthToken,+ 'code' => '12345', // 5 digits+ ])->assertStatus(422)+ ->assertJsonValidationErrors(['code']);++ // Test code that is too long (more than 8)+ $response = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $pendingAuthToken,+ 'code' => '123456789', // 9 digits+ ])->assertStatus(422)+ ->assertJsonValidationErrors(['code']);+ });++ it('handles concurrent verification attempts with same token', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ // Simulate login attempt+ $loginResponse = $this->postJson(route('login'), [+ 'email' => $user->email,+ 'password' => 'password123',+ ]);++ $pendingAuthToken = $loginResponse->json('pending_auth_token');++ // Get recovery codes+ auth('api')->login($user);+ $recoveryCodes = $user->getRecoveryCodes();+ auth('api')->logout();++ // Get one unused recovery code+ $unusedCode = $recoveryCodes->first(function ($code) {+ $usedAt = is_array($code) ? ($code['used_at'] ?? null) : ($code->used_at ?? null);+ return $usedAt === null;+ });++ expect($unusedCode)->not->toBeNull('Recovery code should be available');++ $codeValue = is_string($unusedCode) ? $unusedCode : (is_array($unusedCode) ? $unusedCode['code'] : $unusedCode->code ?? $unusedCode);++ // First request should succeed+ $response1 = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $pendingAuthToken,+ 'code' => $codeValue,+ ]);++ expect($response1->status())->toBe(200, 'First request should succeed');++ // Second request with same token should fail (token already cleared)+ // Use an invalid code since the token is already cleared+ $response2 = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $pendingAuthToken,+ 'code' => '000000',+ ]);++ // Should return 422 or 400 because token was already cleared/used+ // 422 = ValidationException (token not found)+ // 400 = Bad request (could be caught by middleware or other validation)+ expect($response2->status())->toBeIn([400, 422], 'Second request should fail (token already used)');++ // If it's 422, check for validation errors+ if ($response2->status() === 422) {+ expect($response2->json('errors.pending_auth_token'))->toBeArray();+ }+ });++ it('handles concurrent verification attempts with different tokens', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ // Create two login attempts (simulating different sessions)+ $loginResponse1 = $this->postJson(route('login'), [+ 'email' => $user->email,+ 'password' => 'password123',+ ]);++ expect($loginResponse1->status())->toBe(422, 'Login should require 2FA');+ expect($loginResponse1->json('requires_2fa'))->toBeTrue();+ $token1 = $loginResponse1->json('pending_auth_token');++ $loginResponse2 = $this->postJson(route('login'), [+ 'email' => $user->email,+ 'password' => 'password123',+ ]);++ expect($loginResponse2->status())->toBe(422, 'Login should require 2FA');+ expect($loginResponse2->json('requires_2fa'))->toBeTrue();+ $token2 = $loginResponse2->json('pending_auth_token');++ expect($token1)->not->toBe($token2, 'Tokens should be different');++ // Get recovery codes before any verification+ $user = $user->fresh();+ auth('api')->login($user);+ $recoveryCodes = $user->getRecoveryCodes();+ auth('api')->logout();++ $unusedCodes = $recoveryCodes->filter(function ($code) {+ $usedAt = is_array($code) ? ($code['used_at'] ?? null) : ($code->used_at ?? null);+ return $usedAt === null;+ })->take(2);++ expect($unusedCodes->count())->toBeGreaterThanOrEqual(2, 'Need at least 2 unused recovery codes');++ $code1 = $unusedCodes->first();+ $code2 = $unusedCodes->skip(1)->first();++ $codeValue1 = is_string($code1) ? $code1 : (is_array($code1) ? $code1['code'] : $code1->code ?? $code1);+ $codeValue2 = is_string($code2) ? $code2 : (is_array($code2) ? $code2['code'] : $code2->code ?? $code2);++ // Verify both tokens can be verified independently+ // First token verification+ $response1 = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $token1,+ 'code' => $codeValue1,+ ]);++ expect($response1->status())->toBe(200, 'First token should verify successfully');+ expect($response1->json('token'))->toBeString();++ // Logout to allow second verification (TwoFactorVerificationController uses 'guest' middleware)+ auth('api')->logout();++ // Second token verification with different recovery code+ // Note: Recovery codes are single-use per user, but since we're using different codes+ // and different tokens (different sessions), this should work+ $response2 = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $token2,+ 'code' => $codeValue2,+ ]);++ // Both should succeed (different tokens, different recovery codes)+ expect($response2->status())->toBe(200, 'Second token should verify successfully with different recovery code');+ expect($response2->json('token'))->toBeString();+ });++ it('cannot verify with missing pending_auth_token', function () {+ $user = User::factory()->create();+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ $verifyCode = $secret->makeCode();+ $response = $this->postJson(route('two-factor.verify'), [+ 'code' => $verifyCode,+ ]);++ // Should return 422 with validation error for missing token+ expect($response->status())->toBe(422);+ expect($response->json('errors.pending_auth_token'))->toBeArray();+ });++ it('cannot verify with missing code', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ // Simulate login attempt+ $loginResponse = $this->postJson(route('login'), [+ 'email' => $user->email,+ 'password' => 'password123',+ ]);++ $pendingAuthToken = $loginResponse->json('pending_auth_token');++ $response = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $pendingAuthToken,+ ]);++ // Should return 422 with validation error for missing code+ expect($response->status())->toBe(422);+ expect($response->json('errors.code'))->toBeArray();+ });++ it('cannot verify with token for non-existent user', function () {+ $nonExistentUserId = 99999;+ $fakeToken = \Illuminate\Support\Str::random(64);++ // Create a token with non-existent user ID+ Cache::put("2fa_pending:{$fakeToken}", [+ 'user_id' => $nonExistentUserId,+ 'method' => 'password',+ 'remember' => false,+ 'created_at' => now()->toIso8601String(),+ 'context' => [],+ ], now()->addMinutes(10));++ $response = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $fakeToken,+ 'code' => '123456',+ ]);++ // Should return 422 with validation error for user not found+ expect($response->status())->toBe(422);+ expect($response->json('errors.pending_auth_token'))->toBeArray();+ expect($response->json('errors.pending_auth_token.0'))->toContain('not found');+ });++ it('rate limiting resets after time window expires', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ // Simulate login attempt+ $loginResponse = $this->postJson(route('login'), [+ 'email' => $user->email,+ 'password' => 'password123',+ ]);++ $pendingAuthToken = $loginResponse->json('pending_auth_token');++ // Make 5 failed attempts to hit rate limit+ for ($i = 0; $i < 5; $i++) {+ $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $pendingAuthToken,+ 'code' => '000000',+ ])->assertStatus(422);+ }++ // 6th attempt should be rate limited+ $response = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $pendingAuthToken,+ 'code' => '000000',+ ]);+ expect($response->status())->toBe(422);+ expect($response->json('errors.code.0'))->toContain('Too many attempts');++ // Clear rate limiter manually (simulating time window expiration)+ // Use the same key format as the controller: '2fa_verify:' . sha1($pendingAuthToken)+ RateLimiter::clear('2fa_verify:' . sha1($pendingAuthToken));++ // After clearing, should be able to make another attempt (will fail validation but not rate limit)+ $response = $this->postJson(route('two-factor.verify'), [+ 'pending_auth_token' => $pendingAuthToken,+ 'code' => '000000',+ ]);+ expect($response->status())->toBe(422);+ // Should NOT have rate limit message anymore+ $errorMessage = $response->json('errors.code.0');+ expect($errorMessage)->not->toContain('Too many attempts');+ });+});++describe('Login Flow with 2FA', function () {+ it('requires 2FA verification for users with 2FA enabled', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ $response = $this->postJson(route('login'), [+ 'email' => $user->email,+ 'password' => 'password123',+ ])+ ->assertStatus(422)+ ->assertJson([+ 'requires_2fa' => true,+ ])+ ->assertJsonStructure([+ 'pending_auth_token',+ 'user' => ['id', 'name', 'email'],+ ]);++ expect($response->json('user.id'))->toBe($user->id);+ expect($response->json('pending_auth_token'))->toBeString();+ });++ it('allows login without 2FA for users without 2FA enabled', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ ]);++ $response = $this->postJson(route('login'), [+ 'email' => $user->email,+ 'password' => 'password123',+ ])+ ->assertSuccessful()+ ->assertJsonStructure(['token']);++ expect($response->json('requires_2fa'))->toBeNull();+ });++ it('blocks login for blocked users even with 2FA', function () {+ $user = User::factory()->create([+ 'password' => bcrypt('password123'),+ 'blocked_at' => now(),+ ]);+ $secret = $user->createTwoFactorAuth();+ $code = $secret->makeCode();+ $user->confirmTwoFactorAuth($code);++ $this->postJson(route('login'), [+ 'email' => $user->email,+ 'password' => 'password123',+ ])+ ->assertStatus(403);+ });+});diff --git a/client/api/auth.js b/client/api/auth.jsindex c0dadde9d..c83429bd7 100644--- a/client/api/auth.js+++ b/client/api/auth.js@@ -18,5 +18,15 @@ export const authApi = {// OAuthoauth: {callback: (provider, data) => apiService.post(`/oauth/${provider}/callback`, data)+ },++ // Two-factor authentication+ twoFactor: {+ enable: () => apiService.post('/settings/two-factor/enable'),+ confirm: (data) => apiService.post('/settings/two-factor/confirm', data),+ disable: (data) => apiService.post('/settings/two-factor/disable', data),+ recoveryCodes: (data) => apiService.post('/settings/two-factor/recovery-codes', data),+ regenerateRecoveryCodes: (data) => apiService.post('/settings/two-factor/recovery-codes/regenerate', data),+ verify: (data) => apiService.post('/auth/two-factor/verify', data),}}\ No newline at end of filediff --git a/client/components/pages/auth/TwoFactorVerificationModal.vue b/client/components/pages/auth/TwoFactorVerificationModal.vuenew file mode 100644index 000000000..e7c6d52a9--- /dev/null+++ b/client/components/pages/auth/TwoFactorVerificationModal.vue@@ -0,0 +1,188 @@+<template>+ <UModal+ :open="isOpen"+ :ui="{ content: 'sm:max-w-md' }"+ :dismissible="true"+ @close="handleCancel"+ >+ <template #header>+ <h2 class="text-lg font-semibold">Two-Factor Authentication</h2>+ </template>++ <template #body>+ <div class="space-y-4">+ <p class="text-sm text-neutral-600">+ Enter the 6-digit code from your authenticator app.+ </p>++ <div class="flex justify-center">+ <UPinInput+ v-model="code"+ :length="6"+ type="number"+ otp+ autofocus+ size="lg"+ :highlight="!!error"+ @complete="handleComplete"+ @update:model-value="handleCodeChange"+ />+ </div>++ <div v-if="error && hasAttemptedVerification" class="mt-4">+ <UAlert+ color="error"+ variant="subtle"+ :description="error"+ />+ </div>++ <div class="mt-4 text-center">+ <UButton+ variant="link"+ size="sm"+ @click="showRecoveryCode = !showRecoveryCode"+ >+ Use recovery code instead+ </UButton>+ </div>++ <VTransition name="fadeHeight">+ <div v-if="showRecoveryCode" class="mt-4">+ <TextInput+ v-model="recoveryCode"+ label="Recovery Code"+ placeholder="Enter recovery code"+ @keyup.enter="verifyRecoveryCode"+ />+ <UButton+ class="mt-2"+ block+ :loading="verifying"+ @click="verifyRecoveryCode"+ >+ Verify Recovery Code+ </UButton>+ </div>+ </VTransition>+ </div>+ </template>++ <template #footer>+ <div class="flex justify-end gap-2">+ <UButton+ color="neutral"+ variant="outline"+ @click="handleCancel"+ >+ Cancel+ </UButton>+ </div>+ </template>+ </UModal>+</template>++<script setup>+import { authApi } from '~/api/auth'++const props = defineProps({+ show: { type: Boolean, required: true },+ pendingAuthToken: { type: String, default: null },+})++const emit = defineEmits(['verified', 'cancel'])++const isOpen = computed(() => props.show && !!props.pendingAuthToken)++const code = ref([])+const recoveryCode = ref('')+const showRecoveryCode = ref(false)+const verifying = ref(false)+const error = ref(null)+const hasAttemptedVerification = ref(false) // Track if we've actually tried to verify++// Clear error and reset state when modal opens+watch(() => props.show, (isShowing) => {+ if (isShowing) {+ error.value = null+ code.value = []+ recoveryCode.value = ''+ showRecoveryCode.value = false+ verifying.value = false+ hasAttemptedVerification.value = false+ }+}, { immediate: true })+++const handleCodeChange = (value) => {+ // Clear error when user starts typing a new code (only if we've attempted verification before)+ if (error.value && hasAttemptedVerification.value && value && value.length < 6) {+ error.value = null+ }+}++const handleComplete = async (value) => {+ // Only verify if we have exactly 6 digits, we're not already verifying, and value is valid+ if (value && Array.isArray(value) && value.length === 6 && !verifying.value) {+ const codeString = value.join('')+ // Ensure all digits are valid numbers+ if (codeString.length === 6 && /^\d{6}$/.test(codeString)) {+ await verifyCode(codeString)+ }+ }+}++const verifyCode = async (codeValue) => {+ // Validate code format before making API call+ if (!codeValue || codeValue.length !== 6 || !/^\d{6}$/.test(codeValue)) {+ return+ }++ // Validate pending auth token exists+ if (!props.pendingAuthToken) {+ error.value = 'Authentication session expired. Please try logging in again.'+ return+ }++ verifying.value = true+ error.value = null+ hasAttemptedVerification.value = true++ try {+ const response = await authApi.twoFactor.verify({+ pending_auth_token: props.pendingAuthToken,+ code: codeValue,+ })++ emit('verified', response)+ } catch (err) {+ // TanStack Query errors have different structure - check for response or data+ if (err.response) {+ error.value = err.response?._data?.message || err.response?._data?.errors?.code?.[0] || 'Invalid code. Please try again.'+ } else if (err.data) {+ error.value = err.data?.message || err.data?.errors?.code?.[0] || 'Invalid code. Please try again.'+ } else {+ // Network error or other issue+ console.error('2FA verification error:', err)+ error.value = 'Unable to verify code. Please check your connection and try again.'+ }+ code.value = []+ } finally {+ verifying.value = false+ }+}++const verifyRecoveryCode = async () => {+ if (!recoveryCode.value) return+ await verifyCode(recoveryCode.value)+}++const handleCancel = () => {+ code.value = []+ recoveryCode.value = ''+ showRecoveryCode.value = false+ error.value = null+ emit('cancel')+}+</script>+diff --git a/client/components/pages/auth/components/LoginForm.vue b/client/components/pages/auth/components/LoginForm.vueindex 39c03fb18..6c7260721 100644--- a/client/components/pages/auth/components/LoginForm.vue+++ b/client/components/pages/auth/components/LoginForm.vue@@ -5,6 +5,14 @@@close="showForgotModal = false"/>+ <two-factor-verification-modal+ v-if="pendingAuthToken"+ :show="showTwoFactorModal"+ :pending-auth-token="pendingAuthToken"+ @verified="handleTwoFactorVerifiedAndRedirect"+ @cancel="handleTwoFactorCancel"+ />+<v-formmethod="POST":form="form"@@ -126,6 +134,8 @@ defineEmits(['openRegister'])const oAuth = useOAuth()const router = useRouter()const { login: loginMutationFactory } = useAuth()+const authFlow = useAuthFlow()+const { showTwoFactorModal, pendingAuthToken, handleTwoFactorVerified, handleTwoFactorCancel } = authFlow// Feature flagsconst oidcAvailable = computed(() => useFeatureFlag('oidc.available', false))@@ -228,7 +238,10 @@ const login = () => {}form.mutate(loginMutation).then(() => {- redirect()+ // If 2FA modal is shown, don't redirect yet (handled in handleTwoFactorVerified)+ if (!showTwoFactorModal.value) {+ redirect()+ }}).catch((error) => {console.log(error)if (error.response?._data?.message == "You must change your credentials when in self host mode") {@@ -270,4 +283,9 @@ const signInwithGoogle = () => {showOAuthError(error)}}++const handleTwoFactorVerifiedAndRedirect = async (tokenData) => {+ await handleTwoFactorVerified(tokenData)+ redirect()+}</script>diff --git a/client/components/users/settings/Security.vue b/client/components/users/settings/Security.vueindex 173522d8f..37a522b88 100644--- a/client/components/users/settings/Security.vue+++ b/client/components/users/settings/Security.vue@@ -61,24 +61,8 @@</VForm></div>- <!-- Two-Factor Authentication (Future Enhancement) --><div class="pt-8 border-t border-neutral-200">- <div class="flex flex-col gap-2 items-start">- <div>- <h3 class="text-lg font-medium text-neutral-900">Two-Factor Authentication</h3>- <p class="text-sm text-neutral-500 mt-1">- Add an extra layer of security to your account.- </p>- </div>-- <UButton- color="primary"- disabled- >- Coming Soon- </UButton>-- </div>+ <UsersSettingsTwoFactorAuth /></div></div></template>diff --git a/client/components/users/settings/two-factor-auth/DisableTwoFactorModal.vue b/client/components/users/settings/two-factor-auth/DisableTwoFactorModal.vuenew file mode 100644index 000000000..f8f265e62--- /dev/null+++ b/client/components/users/settings/two-factor-auth/DisableTwoFactorModal.vue@@ -0,0 +1,121 @@+<template>+ <UModal+ v-model:open="isOpen"+ :ui="{ content: 'sm:max-w-md' }"+ >+ <template #header>+ <h2 class="text-lg font-semibold">Disable Two-Factor Authentication</h2>+ </template>++ <template #body>+ <div class="space-y-4">+ <UAlert+ color="warning"+ variant="subtle"+ description="Disabling two-factor authentication will reduce the security of your account. Please verify with a code from your authenticator app."+ />++ <div>+ <p class="text-sm font-medium text-neutral-900 mb-2">+ Enter the 6-digit code from your authenticator app:+ </p>+ <div class="flex justify-center mb-4">+ <UPinInput+ v-model="code"+ :length="6"+ type="number"+ otp+ size="lg"+ @complete="handleDisable"+ />+ </div>+ <div class="text-center">+ <UButton+ variant="link"+ size="sm"+ @click="showRecoveryCode = !showRecoveryCode"+ >+ Use recovery code instead+ </UButton>+ </div>+ </div>++ <VTransition name="fadeHeight">+ <div v-if="showRecoveryCode" class="mt-4">+ <TextInput+ v-model="recoveryCode"+ label="Recovery Code"+ placeholder="Enter recovery code"+ @keyup.enter="handleDisable"+ />+ </div>+ </VTransition>+ </div>+ </template>++ <template #footer>+ <div class="flex justify-between w-full gap-2">+ <UButton+ color="neutral"+ variant="outline"+ @click="handleClose"+ >+ Cancel+ </UButton>+ <UButton+ color="error"+ :loading="loading"+ :disabled="code.length !== 6 && !recoveryCode"+ @click="handleDisable"+ >+ Disable 2FA+ </UButton>+ </div>+ </template>+ </UModal>+</template>++<script setup>+const props = defineProps({+ show: { type: Boolean, required: true },+ loading: { type: Boolean, default: false },+})++const emit = defineEmits(['close', 'disable'])++const isOpen = computed({+ get: () => props.show,+ set: (value) => {+ if (!value) emit('close')+ }+})++const code = ref([])+const recoveryCode = ref('')+const showRecoveryCode = ref(false)++const handleDisable = () => {+ const codeValue = code.value.length === 6 ? code.value.join('') : null+ const finalCode = codeValue || recoveryCode.value++ if (finalCode) {+ emit('disable', finalCode)+ }+}++const handleClose = () => {+ code.value = []+ recoveryCode.value = ''+ showRecoveryCode.value = false+ emit('close')+}++watch(() => props.show, (show) => {+ if (!show) {+ code.value = []+ recoveryCode.value = ''+ showRecoveryCode.value = false+ }+})+</script>+diff --git a/client/components/users/settings/two-factor-auth/Index.vue b/client/components/users/settings/two-factor-auth/Index.vuenew file mode 100644index 000000000..6fe5c33f8--- /dev/null+++ b/client/components/users/settings/two-factor-auth/Index.vue@@ -0,0 +1,198 @@+<template>+ <div class="space-y-4">+ <div>+ <h3 class="text-lg font-medium text-neutral-900">Two-Factor Authentication</h3>+ <p class="text-sm text-neutral-500 mt-1">+ Add an extra layer of security to your account using an authenticator app.+ </p>+ </div>++ <!-- 2FA Status -->+ <div v-if="twoFactorEnabled" class="space-y-4">+ <UAlert+ color="success"+ variant="subtle"+ icon="i-heroicons-check-circle"+ description="Two-factor authentication is enabled on your account."+ />++ <div class="flex gap-2">+ <UButton+ color="neutral"+ variant="outline"+ @click="showRegenerateModal = true"+ >+ Regenerate Recovery Codes+ </UButton>+ <UButton+ color="neutral"+ variant="outline"+ @click="showDisableModal = true"+ >+ Disable 2FA+ </UButton>+ </div>+ </div>++ <!-- Enable 2FA Flow -->+ <TwoFactorEnableFlow+ v-else+ :enabling="enabling2FA"+ :confirming="confirming2FA"+ :secret="twoFactorSecret"+ :qr-code="twoFactorQrCode"+ @enable="enableTwoFactor"+ @confirm="confirmTwoFactor"+ />++ <!-- Recovery Codes Modal (shown after setup or regeneration) -->+ <RecoveryCodesModal+ :show="showRecoveryCodesModal"+ :codes="recoveryCodesList"+ :just-regenerated="justRegenerated"+ @close="closeRecoveryCodesModal"+ @copy="copyRecoveryCodes"+ />++ <!-- Regenerate Recovery Codes Modal -->+ <RegenerateRecoveryCodesModal+ :show="showRegenerateModal"+ :loading="regeneratingCodes"+ @close="closeRegenerateModal"+ @regenerate="handleRegenerateRecoveryCodes"+ />++ <!-- Disable 2FA Modal -->+ <DisableTwoFactorModal+ :show="showDisableModal"+ :loading="disabling2FA"+ @close="closeDisableModal"+ @disable="disableTwoFactor"+ />+ </div>+</template>++<script setup>+import { authApi } from '~/api/auth'+import TwoFactorEnableFlow from './TwoFactorEnableFlow.vue'+import RecoveryCodesModal from './RecoveryCodesModal.vue'+import DisableTwoFactorModal from './DisableTwoFactorModal.vue'+import RegenerateRecoveryCodesModal from './RegenerateRecoveryCodesModal.vue'++const alert = useAlert()+const auth = useAuth()+const { data: user } = auth.user()++// Two-Factor Authentication+const twoFactorEnabled = computed(() => user.value?.two_factor_enabled ?? false)+const twoFactorSecret = ref(null)+const twoFactorQrCode = ref(null)+const recoveryCodesList = ref([])+const showRecoveryCodesModal = ref(false)+const showDisableModal = ref(false)+const showRegenerateModal = ref(false)++const enabling2FA = ref(false)+const confirming2FA = ref(false)+const disabling2FA = ref(false)+const regeneratingCodes = ref(false)+const justRegenerated = ref(false)++const enableTwoFactor = async () => {+ enabling2FA.value = true+ try {+ const response = await authApi.twoFactor.enable()+ twoFactorSecret.value = response.secret+ twoFactorQrCode.value = response.qr_code+ } catch (error) {+ alert.error(error.response?._data?.message || 'Failed to enable two-factor authentication')+ } finally {+ enabling2FA.value = false+ }+}++const confirmTwoFactor = async (code) => {+ confirming2FA.value = true+ try {+ const response = await authApi.twoFactor.confirm({ code })++ recoveryCodesList.value = response.recovery_codes || []+ twoFactorSecret.value = null+ twoFactorQrCode.value = null++ // Refresh user data+ await auth.invalidateUser()++ // Show recovery codes modal automatically after enabling+ justRegenerated.value = false+ showRecoveryCodesModal.value = true++ alert.success('Two-factor authentication has been enabled successfully.')+ } catch (error) {+ alert.error(error.response?._data?.message || error.response?._data?.errors?.code?.[0] || 'Invalid code. Please try again.')+ } finally {+ confirming2FA.value = false+ }+}++const disableTwoFactor = async (code) => {+ disabling2FA.value = true+ try {+ await authApi.twoFactor.disable({ code })++ showDisableModal.value = false++ // Refresh user data+ await auth.invalidateUser()++ alert.success('Two-factor authentication has been disabled.')+ } catch (error) {+ alert.error(error.response?._data?.message || error.response?._data?.errors?.code?.[0] || 'Invalid code. Please try again.')+ } finally {+ disabling2FA.value = false+ }+}++const closeRecoveryCodesModal = () => {+ recoveryCodesList.value = []+ justRegenerated.value = false+ showRecoveryCodesModal.value = false+}++const closeRegenerateModal = () => {+ showRegenerateModal.value = false+}++const closeDisableModal = () => {+ showDisableModal.value = false+}++const handleRegenerateRecoveryCodes = async (data) => {+ regeneratingCodes.value = true+ try {+ const response = await authApi.twoFactor.regenerateRecoveryCodes(data)+ recoveryCodesList.value = response.recovery_codes || []+ justRegenerated.value = true+ showRegenerateModal.value = false+ showRecoveryCodesModal.value = true+ alert.success('Recovery codes have been regenerated. Please save them in a safe place.')+ } catch (error) {+ alert.error(error.response?._data?.message || error.response?._data?.errors?.code?.[0] || 'Failed to regenerate recovery codes')+ } finally {+ regeneratingCodes.value = false+ }+}++const { copy: copyToClipboard } = useClipboard()++const copyRecoveryCodes = () => {+ // Extract just the codes from objects+ const codes = recoveryCodesList.value.map(item =>+ typeof item === 'string' ? item : item.code+ )+ const codesText = codes.join('\n')+ copyToClipboard(codesText)+ alert.success('Recovery codes copied to clipboard')+}+</script>+diff --git a/client/components/users/settings/two-factor-auth/RecoveryCodesModal.vue b/client/components/users/settings/two-factor-auth/RecoveryCodesModal.vuenew file mode 100644index 000000000..c07822e13--- /dev/null+++ b/client/components/users/settings/two-factor-auth/RecoveryCodesModal.vue@@ -0,0 +1,90 @@+<template>+ <UModal+ v-model:open="isOpen"+ :ui="{ content: 'sm:max-w-md' }"+ >+ <template #header>+ <h2 class="text-lg font-semibold">Recovery Codes</h2>+ </template>++ <template #body>+ <div class="space-y-4">+ <!-- Recovery codes display -->+ <div v-if="codes.length > 0" class="space-y-4">+ <UAlert+ color="warning"+ variant="subtle"+ description="These recovery codes will only be shown once. Please save them in a safe place. You can use them to access your account if you lose access to your authenticator device."+ />++ <div class="space-y-2">+ <div+ v-for="(codeItem, index) in codes"+ :key="index"+ class="flex items-center justify-center p-2 bg-neutral-50 rounded font-mono text-sm text-center"+ >+ <span>{{ typeof codeItem === 'string' ? codeItem : codeItem.code }}</span>+ <span+ v-if="typeof codeItem === 'object' && codeItem.used_at"+ class="text-xs text-neutral-500 ml-2 font-sans"+ >+ Used {{ formatDate(codeItem.used_at) }}+ </span>+ </div>+ </div>++ <div class="flex gap-2">+ <UButton+ block+ color="neutral"+ variant="outline"+ @click="handleCopy"+ >+ Copy All Codes+ </UButton>+ <UButton+ block+ color="primary"+ @click="handleClose"+ >+ I've Saved These Codes+ </UButton>+ </div>+ </div>+ </div>+ </template>+ </UModal>+</template>++<script setup>+const props = defineProps({+ show: { type: Boolean, required: true },+ codes: { type: Array, default: () => [] },+ justRegenerated: { type: Boolean, default: false },+})++const emit = defineEmits(['close', 'copy'])++const isOpen = computed({+ get: () => props.show,+ set: (value) => {+ if (!value) emit('close')+ }+})++const handleCopy = () => {+ emit('copy')+}++const handleClose = () => {+ emit('close')+}++const formatDate = (dateString) => {+ if (!dateString) return ''+ const date = new Date(dateString)+ return date.toLocaleDateString() + ' ' + date.toLocaleTimeString([], { hour: '2-digit', minute: '2-digit' })+}++</script>+diff --git a/client/components/users/settings/two-factor-auth/RegenerateRecoveryCodesModal.vue b/client/components/users/settings/two-factor-auth/RegenerateRecoveryCodesModal.vuenew file mode 100644index 000000000..8b7975415--- /dev/null+++ b/client/components/users/settings/two-factor-auth/RegenerateRecoveryCodesModal.vue@@ -0,0 +1,124 @@+<template>+ <UModal+ v-model:open="isOpen"+ :ui="{ content: 'sm:max-w-md' }"+ >+ <template #header>+ <h2 class="text-lg font-semibold">Regenerate Recovery Codes</h2>+ </template>++ <template #body>+ <div class="space-y-4">+ <UAlert+ color="warning"+ variant="subtle"+ description="Regenerating recovery codes will invalidate all existing codes. You'll need to save the new codes immediately."+ />++ <div>+ <p class="text-sm font-medium text-neutral-900 mb-2">+ Enter the 6-digit code from your authenticator app:+ </p>+ <div class="flex justify-center mb-4">+ <UPinInput+ v-model="code"+ :length="6"+ type="number"+ otp+ size="lg"+ autofocus+ @complete="handleSubmit"+ />+ </div>+ <div class="text-center">+ <UButton+ variant="link"+ size="sm"+ @click="showRecoveryCode = !showRecoveryCode"+ >+ Use recovery code instead+ </UButton>+ </div>+ </div>++ <VTransition name="fadeHeight">+ <div v-if="showRecoveryCode" class="mt-4">+ <TextInput+ v-model="recoveryCode"+ label="Recovery Code"+ placeholder="Enter recovery code"+ @keyup.enter="handleSubmit"+ />+ </div>+ </VTransition>+ </div>+ </template>++ <template #footer>+ <div class="flex justify-end gap-2">+ <UButton+ color="neutral"+ variant="outline"+ @click="handleClose"+ >+ Cancel+ </UButton>+ <UButton+ color="primary"+ :loading="loading"+ :disabled="code.length !== 6 && !recoveryCode"+ @click="handleSubmit"+ >+ Regenerate Codes+ </UButton>+ </div>+ </template>+ </UModal>+</template>++<script setup>+const props = defineProps({+ show: { type: Boolean, required: true },+ loading: { type: Boolean, default: false },+})++const emit = defineEmits(['close', 'regenerate'])++const isOpen = computed({+ get: () => props.show,+ set: (value) => {+ if (!value) emit('close')+ }+})++const code = ref([])+const recoveryCode = ref('')+const showRecoveryCode = ref(false)++const handleSubmit = () => {+ const codeValue = code.value.length === 6 ? code.value.join('') : null+ const finalCode = codeValue || recoveryCode.value++ if (finalCode) {+ emit('regenerate', {+ code: finalCode+ })+ }+}++const handleClose = () => {+ code.value = []+ recoveryCode.value = ''+ showRecoveryCode.value = false+ emit('close')+}++watch(() => props.show, (show) => {+ if (!show) {+ code.value = []+ recoveryCode.value = ''+ showRecoveryCode.value = false+ }+})+</script>+diff --git a/client/components/users/settings/two-factor-auth/TwoFactorAuth.vue b/client/components/users/settings/two-factor-auth/TwoFactorAuth.vuenew file mode 100644index 000000000..b5c8bc33a--- /dev/null+++ b/client/components/users/settings/two-factor-auth/TwoFactorAuth.vue@@ -0,0 +1,213 @@+<template>+ <div class="space-y-4">+ <div>+ <h3 class="text-lg font-medium text-neutral-900">Two-Factor Authentication</h3>+ <p class="text-sm text-neutral-500 mt-1">+ Add an extra layer of security to your account using an authenticator app.+ </p>+ </div>++ <!-- 2FA Status -->+ <div v-if="twoFactorEnabled" class="space-y-4">+ <UAlert+ color="success"+ variant="subtle"+ icon="i-heroicons-check-circle"+ description="Two-factor authentication is enabled on your account."+ />++ <div class="flex gap-2">+ <UButton+ color="neutral"+ variant="outline"+ @click="openRecoveryCodesModal"+ >+ View Recovery Codes+ </UButton>+ <UButton+ color="neutral"+ variant="outline"+ @click="showDisableModal = true"+ >+ Disable 2FA+ </UButton>+ </div>+ </div>++ <!-- Enable 2FA Flow -->+ <TwoFactorEnableFlow+ v-else+ :enabling="enabling2FA"+ :confirming="confirming2FA"+ :secret="twoFactorSecret"+ :qr-code="twoFactorQrCode"+ @enable="enableTwoFactor"+ @confirm="confirmTwoFactor"+ />++ <!-- Recovery Codes Modal -->+ <RecoveryCodesModal+ :show="showRecoveryCodesModal"+ :codes="recoveryCodesList"+ :loading="loadingRecoveryCodes"+ :regenerating="regeneratingCodes"+ :just-regenerated="justRegenerated"+ @close="closeRecoveryCodesModal"+ @load="loadRecoveryCodesWithPassword"+ @regenerate="handleRegenerateRecoveryCodes"+ @copy="copyRecoveryCodes"+ />++ <!-- Disable 2FA Modal -->+ <DisableTwoFactorModal+ :show="showDisableModal"+ :loading="disabling2FA"+ @close="closeDisableModal"+ @disable="disableTwoFactor"+ />+ </div>+</template>++<script setup>+import { useTwoFactor } from '~/composables/query/useTwoFactor'+import TwoFactorEnableFlow from './TwoFactorEnableFlow.vue'+import RecoveryCodesModal from './RecoveryCodesModal.vue'+import DisableTwoFactorModal from './DisableTwoFactorModal.vue'++const alert = useAlert()+const auth = useAuth()+const { data: user } = auth.user()++// Two-Factor Authentication+const { enable, confirm, disable, recoveryCodes: getRecoveryCodes, regenerateRecoveryCodes } = useTwoFactor()++const twoFactorEnabled = computed(() => user.value?.two_factor_enabled ?? false)+const twoFactorSecret = ref(null)+const twoFactorQrCode = ref(null)+const recoveryCodesList = ref([])+const showRecoveryCodesModal = ref(false)+const showDisableModal = ref(false)++const enabling2FA = ref(false)+const confirming2FA = ref(false)+const disabling2FA = ref(false)+const loadingRecoveryCodes = ref(false)+const regeneratingCodes = ref(false)+const justRegenerated = ref(false)++const enableMutation = enable()+const confirmMutation = confirm()+const disableMutation = disable()+const recoveryCodesMutation = getRecoveryCodes()+const regenerateMutation = regenerateRecoveryCodes()++const enableTwoFactor = async () => {+ enabling2FA.value = true+ try {+ const response = await enableMutation.mutateAsync()+ twoFactorSecret.value = response.secret+ twoFactorQrCode.value = response.qr_code+ } catch (error) {+ alert.error(error.response?._data?.message || 'Failed to enable two-factor authentication')+ } finally {+ enabling2FA.value = false+ }+}++const confirmTwoFactor = async (code) => {+ confirming2FA.value = true+ try {+ const response = await confirmMutation.mutateAsync({ code })++ recoveryCodesList.value = response.recovery_codes || []+ twoFactorSecret.value = null+ twoFactorQrCode.value = null++ // Refresh user data+ await auth.invalidateUser()++ // Show recovery codes modal automatically after enabling+ justRegenerated.value = false+ showRecoveryCodesModal.value = true++ alert.success('Two-factor authentication has been enabled successfully.')+ } catch (error) {+ alert.error(error.response?._data?.message || error.response?._data?.errors?.code?.[0] || 'Invalid code. Please try again.')+ } finally {+ confirming2FA.value = false+ }+}++const disableTwoFactor = async (code) => {+ disabling2FA.value = true+ try {+ await disableMutation.mutateAsync({ code })++ showDisableModal.value = false++ // Refresh user data+ await auth.invalidateUser()++ alert.success('Two-factor authentication has been disabled.')+ } catch (error) {+ alert.error(error.response?._data?.message || error.response?._data?.errors?.code?.[0] || 'Invalid code. Please try again.')+ } finally {+ disabling2FA.value = false+ }+}++const openRecoveryCodesModal = () => {+ recoveryCodesList.value = []+ justRegenerated.value = false+ showRecoveryCodesModal.value = true+}++const closeRecoveryCodesModal = () => {+ showRecoveryCodesModal.value = false+}++const closeDisableModal = () => {+ showDisableModal.value = false+}++const loadRecoveryCodesWithPassword = async (password) => {+ loadingRecoveryCodes.value = true+ try {+ const response = await recoveryCodesMutation.mutateAsync({ password })+ recoveryCodesList.value = response.recovery_codes || []+ } catch (error) {+ alert.error(error.response?._data?.message || error.response?._data?.errors?.password?.[0] || 'Failed to load recovery codes')+ } finally {+ loadingRecoveryCodes.value = false+ }+}++const handleRegenerateRecoveryCodes = async () => {+ regeneratingCodes.value = true+ try {+ const response = await regenerateMutation.mutateAsync()+ recoveryCodesList.value = response.recovery_codes || []+ justRegenerated.value = true+ alert.success('Recovery codes have been regenerated. Please save them in a safe place.')+ } catch (error) {+ alert.error(error.response?._data?.message || 'Failed to regenerate recovery codes')+ } finally {+ regeneratingCodes.value = false+ }+}++const copyRecoveryCodes = async () => {+ try {+ // Extract just the codes from objects+ const codes = recoveryCodesList.value.map(item =>+ typeof item === 'string' ? item : item.code+ )+ const codesText = codes.join('\n')+ await navigator.clipboard.writeText(codesText)+ alert.success('Recovery codes copied to clipboard')+ } catch {+ alert.error('Failed to copy recovery codes')+ }+}+</script>+diff --git a/client/components/users/settings/two-factor-auth/TwoFactorEnableFlow.vue b/client/components/users/settings/two-factor-auth/TwoFactorEnableFlow.vuenew file mode 100644index 000000000..df827e5ec--- /dev/null+++ b/client/components/users/settings/two-factor-auth/TwoFactorEnableFlow.vue@@ -0,0 +1,91 @@+<template>+ <div class="space-y-4">+ <UButton+ color="primary"+ :loading="enabling"+ @click="handleEnable"+ >+ Enable Two-Factor Authentication+ </UButton>++ <!-- QR Code Display -->+ <VTransition name="fadeHeight">+ <div v-if="secret" class="space-y-4 p-4 border border-neutral-200 rounded-lg bg-neutral-50">+ <div>+ <p class="text-sm font-medium text-neutral-900 mb-2">+ Scan this QR code with your authenticator app:+ </p>+ <div class="flex justify-center p-4 bg-white rounded-lg max-w-xs mx-auto">+ <div v-html="qrCode" class="flex" />+ </div>+ </div>++ <div>+ <p class="text-sm font-medium text-neutral-900 mb-2">+ Or enter this code manually:+ </p>+ <CopyContent+ :content="secret"+ label="Copy Secret"+ />+ </div>++ <div>+ <p class="text-sm font-medium text-neutral-900 mb-2">+ Enter the 6-digit code from your authenticator app to confirm:+ </p>+ <div class="flex justify-center mb-4">+ <UPinInput+ v-model="code"+ :length="6"+ type="number"+ otp+ size="lg"+ @complete="handleConfirm"+ />+ </div>+ <UButton+ block+ :loading="confirming"+ :disabled="code.length !== 6"+ @click="handleConfirm"+ >+ Confirm and Enable+ </UButton>+ </div>+ </div>+ </VTransition>+ </div>+</template>++<script setup>+import CopyContent from '~/components/open/forms/components/CopyContent.vue'++const props = defineProps({+ enabling: { type: Boolean, default: false },+ confirming: { type: Boolean, default: false },+ secret: { type: String, default: null },+ qrCode: { type: String, default: null },+})++const emit = defineEmits(['enable', 'confirm'])++const code = ref([])++const handleEnable = () => {+ emit('enable')+}++const handleConfirm = () => {+ if (code.value.length === 6) {+ emit('confirm', code.value.join(''))+ }+}++watch(() => props.secret, (newSecret) => {+ if (!newSecret) {+ code.value = []+ }+})+</script>+diff --git a/client/components/vendor/GoogleOneTap.vue b/client/components/vendor/GoogleOneTap.vueindex e143a0f5f..f173d5094 100644--- a/client/components/vendor/GoogleOneTap.vue+++ b/client/components/vendor/GoogleOneTap.vue@@ -1,12 +1,22 @@<template>- <div- v-if="shouldShowOneTap"- id="g_id_onload"- :data-client_id="googleClientId"- :data-context="context"- :data-cancel_on_tap_outside="false"- data-use_fedcm_for_prompt="false"- />+ <div>+ <two-factor-verification-modal+ v-if="pendingAuthToken"+ :show="showTwoFactorModal"+ :pending-auth-token="pendingAuthToken"+ @verified="handleTwoFactorVerifiedAndRedirect"+ @cancel="handleTwoFactorCancel"+ />++ <div+ v-if="shouldShowOneTap"+ id="g_id_onload"+ :data-client_id="googleClientId"+ :data-context="context"+ :data-cancel_on_tap_outside="false"+ data-use_fedcm_for_prompt="false"+ />+ </div></template><script setup>@@ -26,6 +36,7 @@ const widgetCallbackMutation = widgetCallback()const oneTapInitialized = ref(false)const googleClientId = computed(() => useFeatureFlag('services.google.client_id'))const authFlow = useAuthFlow()+const { showTwoFactorModal, pendingAuthToken, handleTwoFactorVerified, handleTwoFactorCancel: handleTwoFactorCancelFromFlow, handleTwoFactorError } = authFlowconst router = useRouter()// Only show One Tap if Google auth is enabled and user is not authenticated@@ -103,11 +114,42 @@ const initializeOneTap = () => {}}+const handleTwoFactorCancel = () => {+ // User cancelled 2FA, close the modal+ handleTwoFactorCancelFromFlow()+ // No redirect needed as they're still on the same page+}++const handleTwoFactorVerifiedAndRedirect = async (tokenData) => {+ await handleTwoFactorVerified(tokenData)++ // Handle redirect based on user status+ if (tokenData.new_user) {+ router.push({ name: "forms-create" })+ useAlert().success("You're now registered with your Google account! Welcome to OpnForm.")+ useAlert().success("Time to create your first form!")+ } else {+ useAlert().success('Successfully signed in with Google!')+ router.push({ name: "home" })+ }+}+const handleAuthenticationResponse = async (response) => {try {// Handle authentication flow (user was not logged in)+ // handleAuthSuccess will check for requires_2fa and show modal if neededawait authFlow.handleAuthSuccess(response, 'google_one_tap', response.new_user)+ // If 2FA modal is shown, don't redirect yet (handled in handleTwoFactorVerifiedAndRedirect)+ if (showTwoFactorModal.value) {+ return+ }++ // Only proceed with redirect if we have a token (2FA not required)+ if (!response.token) {+ return+ }+if (!response.new_user) {// Handle existing user loginuseAlert().success('Successfully signed in with Google!')@@ -158,15 +200,22 @@ const handleCredentialResponse = (response) => {data: requestData}).then((response) => {// Handle both authentication and integration responses- if (response.token) {+ if (response.token || (response.requires_2fa && response.pending_auth_token)) {// Authentication flow - user was not logged in+ // handleAuthSuccess will check for requires_2fa and show modal if neededhandleAuthenticationResponse(response)} else {useAlert().error('Google One Tap authentication failed')}}).catch((error) => {- console.error('Google One Tap authentication error:', error)- useAlert().error(error.response?._data?.message || 'Google One Tap authentication failed')+ // Handle 422 responses that indicate 2FA is required (not validation errors)+ const twoFactorResponse = handleTwoFactorError(error)+ if (twoFactorResponse) {+ handleAuthenticationResponse(twoFactorResponse)+ } else {+ console.error('Google One Tap authentication error:', error)+ useAlert().error(error.response?._data?.message || 'Google One Tap authentication failed')+ }})}diff --git a/client/composables/useAuthFlow.js b/client/composables/useAuthFlow.jsindex ca5ea2f1b..4c87e3bac 100644--- a/client/composables/useAuthFlow.js+++ b/client/composables/useAuthFlow.js@@ -32,11 +32,33 @@ export const useAuthFlow = () => {const { logEvent } = useAmplitude()const router = useRouter()+ // 2FA modal state+ const showTwoFactorModal = ref(false)+ const pendingAuthToken = ref(null)+ const pendingAuthContext = ref(null)+/*** Core authentication success handler- * Coordinates token storage, analytics, and UI feedback (cache management handled by useAuth)+ * Now checks for 2FA requirement before proceeding*/const handleAuthSuccess = async (tokenData, source, isNewUser = false) => {+ // Check if 2FA is required+ if (tokenData.requires_2fa && tokenData.pending_auth_token) {+ // Store pending auth context and show modal+ pendingAuthToken.value = tokenData.pending_auth_token+ pendingAuthContext.value = { source, isNewUser }+ showTwoFactorModal.value = true+ return+ }++ // No 2FA required, proceed with normal flow+ await proceedWithAuthSuccess(tokenData, source, isNewUser)+ }++ /**+ * Proceed with authentication after 2FA verification or when 2FA not required+ */+ const proceedWithAuthSuccess = async (tokenData, source, isNewUser = false) => {// 1. Set token in storeauthStore.setToken(tokenData.token, tokenData.expires_in)@@ -78,6 +100,49 @@ export const useAuthFlow = () => {}}+ /**+ * Handle 2FA error responses consistently+ * Checks if a 422 error is actually a 2FA requirement (not a validation error)+ * @param {Error} error - The error object from the API call+ * @returns {Object|null} - The response data if it's a 2FA requirement, null otherwise+ */+ const handleTwoFactorError = (error) => {+ // Check if this is a 422 response with requires_2fa flag+ if (error.response?.status === 422 && error.response?._data?.requires_2fa) {+ // This is a 2FA requirement, not a validation error+ return error.response._data+ }+ // This is a real error, return null to indicate it should be thrown+ return null+ }++ /**+ * Handle 2FA verification cancellation+ */+ const handleTwoFactorCancel = () => {+ showTwoFactorModal.value = false+ pendingAuthToken.value = null+ pendingAuthContext.value = null+ }++ /**+ * Handle 2FA verification success+ */+ const handleTwoFactorVerified = async (tokenData) => {+ showTwoFactorModal.value = false++ // Proceed with auth success using verified token data+ await proceedWithAuthSuccess(+ tokenData,+ pendingAuthContext.value?.source || 'credentials',+ pendingAuthContext.value?.isNewUser || false+ )++ // Clear pending context+ pendingAuthToken.value = null+ pendingAuthContext.value = null+ }+/*** Handle social login callback*/@@ -154,6 +219,13 @@ export const useAuthFlow = () => {// Distinct logout methodshandleManualLogout,- handleTokenExpiry+ handleTokenExpiry,++ // 2FA modal state and handlers+ showTwoFactorModal,+ pendingAuthToken,+ handleTwoFactorVerified,+ handleTwoFactorCancel,+ handleTwoFactorError,}}\ No newline at end of filediff --git a/client/pages/auth/[slug]/callback.vue b/client/pages/auth/[slug]/callback.vueindex 4024e96d4..ac24af8d8 100644--- a/client/pages/auth/[slug]/callback.vue+++ b/client/pages/auth/[slug]/callback.vue@@ -1,12 +1,20 @@<template><div class="flex flex-grow mt-6 mb-10">+ <two-factor-verification-modal+ v-if="pendingAuthToken"+ :show="showTwoFactorModal"+ :pending-auth-token="pendingAuthToken"+ @verified="handleTwoFactorVerifiedAndRedirect"+ @cancel="handleTwoFactorCancel"+ />+<div class="w-full md:w-2/3 md:mx-auto md:max-w-md px-4"><div- v-if="loading"+ v-if="loading || showTwoFactorModal"class="m-10"><h3 class="my-6 text-center">- Completing sign in...+ {{ showTwoFactorModal ? 'Verifying your code...' : 'Completing sign in...' }}</h3><Loader class="h-6 w-6 mx-auto m-10" /></div>@@ -38,6 +46,7 @@ const route = useRoute()const loading = ref(true)const error = ref(null)const authFlow = useAuthFlow()+const { showTwoFactorModal, pendingAuthToken, handleTwoFactorVerified, handleTwoFactorCancel: handleTwoFactorCancelFromFlow, handleTwoFactorError } = authFlowconst handleCallback = async () => {const slug = route.params.slug@@ -52,25 +61,44 @@ const handleCallback = async () => {})// Call the OIDC callback endpoint to process authorization code- const response = await oidcApi.callback(slug, queryParams)-- // Response should contain token and user- if (response.token && response.user) {- // Handle authentication success (response already has the right structure)- await authFlow.handleAuthSuccess(response, 'oidc', response.new_user)-- // Redirect based on user status (aligned with OAuth callback pattern)- if (response.new_user) {- router.push({ name: "forms-create" })- useAlert().success("Success! You're now registered with OIDC. Welcome to OpnForm.")+ let response+ try {+ response = await oidcApi.callback(slug, queryParams)+ } catch (error) {+ // Handle 422 responses that indicate 2FA is required (not validation errors)+ const twoFactorResponse = handleTwoFactorError(error)+ if (twoFactorResponse) {+ response = twoFactorResponse} else {- // For existing users, redirect to intended URL or home (aligned with OAuth)- router.push({ name: "home" })- useAlert().success("Successfully signed in!")+ throw error}- } else {+ }++ // Handle authentication success (handles both 2FA and non-2FA cases)+ // handleAuthSuccess will check for requires_2fa and show modal if needed+ await authFlow.handleAuthSuccess(response, 'oidc', response.new_user)++ // If 2FA modal is shown, don't redirect yet (handled in handleTwoFactorVerifiedAndRedirect)+ if (showTwoFactorModal.value) {+ loading.value = false+ return+ }++ // No 2FA required, proceed with redirect+ // Response should contain token and user when 2FA is not required+ if (!response.token || !response.user) {throw new Error("Unexpected response format from OIDC callback")}++ // Redirect based on user status (aligned with OAuth callback pattern)+ if (response.new_user) {+ router.push({ name: "forms-create" })+ useAlert().success("Success! You're now registered with OIDC. Welcome to OpnForm.")+ } else {+ // For existing users, redirect to intended URL or home (aligned with OAuth)+ router.push({ name: "home" })+ useAlert().success("Successfully signed in!")+ }} catch (err) {console.error("[OIDC Callback] Authentication error:", err)@@ -88,6 +116,24 @@ const handleCallback = async () => {}}+const handleTwoFactorCancel = () => {+ handleTwoFactorCancelFromFlow()+ router.push({ name: 'login' })+}++const handleTwoFactorVerifiedAndRedirect = async (tokenData) => {+ await handleTwoFactorVerified(tokenData)++ // Redirect based on user status+ if (tokenData.new_user) {+ router.push({ name: "forms-create" })+ useAlert().success("Success! You're now registered with OIDC. Welcome to OpnForm.")+ } else {+ router.push({ name: "home" })+ useAlert().success("Successfully signed in!")+ }+}+onMounted(() => {// Set a timeout to ensure we don't get stuck in loading stateconst timeoutId = setTimeout(() => {diff --git a/client/pages/oauth/[provider]/callback.vue b/client/pages/oauth/[provider]/callback.vueindex b8c1b50ac..b158e0203 100644--- a/client/pages/oauth/[provider]/callback.vue+++ b/client/pages/oauth/[provider]/callback.vue@@ -1,12 +1,20 @@<template><div class="flex flex-grow mt-6 mb-10">+ <two-factor-verification-modal+ v-if="pendingAuthToken"+ :show="showTwoFactorModal"+ :pending-auth-token="pendingAuthToken"+ @verified="handleTwoFactorVerifiedAndRedirect"+ @cancel="handleTwoFactorCancel"+ />+<div class="w-full md:w-2/3 md:mx-auto md:max-w-md px-4"><div- v-if="loading"+ v-if="loading || showTwoFactorModal"class="m-10"><h3 class="my-6 text-center">- Please wait...+ {{ showTwoFactorModal ? 'Verifying your code...' : 'Please wait...' }}</h3><Loader class="h-6 w-6 mx-auto m-10" /></div>@@ -34,6 +42,7 @@ const router = useRouter()const route = useRoute()const loading = ref(true)const authFlow = useAuthFlow()+const { showTwoFactorModal, pendingAuthToken, handleTwoFactorVerified, handleTwoFactorCancel: handleTwoFactorCancelFromFlow, handleTwoFactorError } = authFlowconst loginMessage = useWindowMessage(WindowMessageTypes.LOGIN_COMPLETE)const providerMessage = useWindowMessage(WindowMessageTypes.OAUTH_PROVIDER_CONNECTED)@@ -59,14 +68,34 @@ const handleCallback = async () => {}// Call the OAuth callback endpoint directly to get the raw response- const response = await authApi.oauth.callback(provider, payloadData)+ let response+ try {+ response = await authApi.oauth.callback(provider, payloadData)+ } catch (error) {+ // Handle 422 responses that indicate 2FA is required (not validation errors)+ const twoFactorResponse = handleTwoFactorError(error)+ if (twoFactorResponse) {+ response = twoFactorResponse+ } else {+ throw error+ }+ }- // Check if this is an authentication response (has token) or integration response (has provider)- if (response.token) {+ // Check if this is an authentication response (has token or requires_2fa) or integration response (has provider)+ if (response.token || (response.requires_2fa && response.pending_auth_token)) {// Authentication flow - user was not logged in+ // handleAuthSuccess will check for requires_2fa and show modal if neededawait authFlow.handleAuthSuccess(response, provider, response.new_user)- if (!response.new_user) {+ // If 2FA modal is shown, don't redirect yet (handled in handleTwoFactorVerifiedAndRedirect)+ if (showTwoFactorModal.value) {+ loading.value = false+ return+ }++ // Only proceed with redirect if we have a token (2FA not required)+ // If requires_2fa is true, we already returned above+ if (response.token && !response.new_user) {// Handle existing user loginif (window.opener) {try {@@ -135,6 +164,42 @@ const handleCallback = async () => {}}+const handleTwoFactorCancel = () => {+ handleTwoFactorCancelFromFlow()+ router.push({ name: 'login' })+}++const handleTwoFactorVerifiedAndRedirect = async (tokenData) => {+ await handleTwoFactorVerified(tokenData)++ // Handle redirect based on user status+ if (tokenData.new_user) {+ router.push({ name: "forms-create" })+ useAlert().success("Success! You're now registered with your Google account! Welcome to OpnForm.")+ } else {+ if (window.opener) {+ try {+ await Promise.all([+ loginMessage.send(window.opener, {+ waitForAcknowledgment: true,+ timeout: 500+ }),+ providerMessage.send(window.opener, {+ useMessageChannel: false,+ waitForAcknowledgment: false+ })+ ])++ window.close()+ } catch {+ router.push({ name: "home" })+ }+ } else {+ router.push({ name: "home" })+ }+ }+}+onMounted(() => {// Set a timeout to ensure we don't get stuck in loading stateconst timeoutId = setTimeout(() => {diff --git a/client/test/nuxt/two-factor-enable-flow.spec.ts b/client/test/nuxt/two-factor-enable-flow.spec.tsnew file mode 100644index 000000000..a1ab4dff9--- /dev/null+++ b/client/test/nuxt/two-factor-enable-flow.spec.ts@@ -0,0 +1,189 @@+import { describe, it, expect, beforeEach, vi } from 'vitest'+import { mount } from '@vue/test-utils'+import TwoFactorEnableFlow from '~/components/users/settings/two-factor-auth/TwoFactorEnableFlow.vue'++describe('TwoFactorEnableFlow', () => {+ const createWrapper = (props = {}) => {+ return mount(TwoFactorEnableFlow, {+ props: {+ enabling: false,+ confirming: false,+ secret: null,+ qrCode: null,+ ...props,+ },+ global: {+ stubs: {+ UButton: {+ template: '<button @click="$emit(\'click\')" :disabled="disabled" :class="{ loading }"><slot /></button>',+ props: ['color', 'loading', 'block', 'disabled'],+ emits: ['click'],+ },+ UPinInput: {+ template: '<input type="text" data-testid="pin-input" />',+ props: ['modelValue', 'length', 'type', 'otp', 'size'],+ emits: ['update:modelValue', 'complete'],+ },+ CopyContent: {+ template: '<div class="copy-content">{{ content }}</div>',+ props: ['content', 'label'],+ },+ VTransition: {+ template: '<div><slot /></div>',+ props: ['name'],+ },+ },+ },+ })+ }++ describe('Initial State', () => {+ it('should render enable button when secret is not provided', () => {+ const wrapper = createWrapper()++ expect(wrapper.exists()).toBe(true)+ const button = wrapper.find('button')+ expect(button.text()).toContain('Enable Two-Factor Authentication')+ })++ it('should not show QR code section initially', () => {+ const wrapper = createWrapper()++ const qrSection = wrapper.find('.border')+ expect(qrSection.exists()).toBe(false)+ })+ })++ describe('Enable Flow', () => {+ it('should emit enable event when enable button is clicked', async () => {+ const wrapper = createWrapper()++ const button = wrapper.find('button')+ await button.trigger('click')++ expect(wrapper.emitted('enable')).toBeTruthy()+ expect(wrapper.emitted('enable')).toHaveLength(1)+ })++ it('should show loading state on enable button when enabling', () => {+ const wrapper = createWrapper({ enabling: true })++ const button = wrapper.find('button')+ expect(button.classes()).toContain('loading')+ })+ })++ describe('QR Code Display', () => {+ it('should display QR code when secret is provided', () => {+ const wrapper = createWrapper({+ secret: 'TEST_SECRET_123',+ qrCode: '<svg>QR Code</svg>',+ })++ const qrSection = wrapper.find('.border')+ expect(qrSection.exists()).toBe(true)+ })++ it('should display secret section when secret is provided', () => {+ const wrapper = createWrapper({+ secret: 'TEST_SECRET_123',+ qrCode: '<svg>QR Code</svg>',+ })++ // Should show manual entry section+ expect(wrapper.text()).toContain('Or enter this code manually')+ })++ it('should show confirmation section when secret is provided', () => {+ const wrapper = createWrapper({+ secret: 'TEST_SECRET_123',+ qrCode: '<svg>QR Code</svg>',+ })++ // QR section should be visible+ const qrSection = wrapper.find('.border')+ expect(qrSection.exists()).toBe(true)++ // Should have text about entering code+ expect(wrapper.text()).toContain('Enter the 6-digit code')+ })+ })++ describe('Confirmation', () => {+ it('should emit confirm event with code when handleConfirm is called with 6 digits', () => {+ const wrapper = createWrapper({+ secret: 'TEST_SECRET_123',+ qrCode: '<svg>QR Code</svg>',+ })++ // Set code to 6 digits+ wrapper.vm.code = ['1', '2', '3', '4', '5', '6']+ wrapper.vm.handleConfirm()++ expect(wrapper.emitted('confirm')).toBeTruthy()+ expect(wrapper.emitted('confirm')[0]).toEqual(['123456'])+ })++ it('should not emit confirm if code is not 6 digits', () => {+ const wrapper = createWrapper({+ secret: 'TEST_SECRET_123',+ qrCode: '<svg>QR Code</svg>',+ })++ wrapper.vm.code = ['1', '2', '3']+ wrapper.vm.handleConfirm()++ expect(wrapper.emitted('confirm')).toBeFalsy()+ })++ it('should disable confirm button when code is not 6 digits', async () => {+ const wrapper = createWrapper({+ secret: 'TEST_SECRET_123',+ qrCode: '<svg>QR Code</svg>',+ })++ wrapper.vm.code = ['1', '2', '3']+ await wrapper.vm.$nextTick()++ const buttons = wrapper.findAll('button')+ const confirmButton = buttons.find(btn => btn.text().includes('Confirm'))++ if (confirmButton) {+ expect(confirmButton.attributes('disabled')).toBeDefined()+ }+ })++ it('should show loading state on confirm button when confirming', () => {+ const wrapper = createWrapper({+ secret: 'TEST_SECRET_123',+ qrCode: '<svg>QR Code</svg>',+ confirming: true,+ })++ const buttons = wrapper.findAll('button')+ const confirmButton = buttons.find(btn => btn.text().includes('Confirm'))++ if (confirmButton) {+ expect(confirmButton.classes()).toContain('loading')+ }+ })+ })++ describe('State Reset', () => {+ it('should clear code when secret is cleared', async () => {+ const wrapper = createWrapper({+ secret: 'TEST_SECRET_123',+ qrCode: '<svg>QR Code</svg>',+ })++ wrapper.vm.code = ['1', '2', '3', '4', '5', '6']++ // Clear secret+ await wrapper.setProps({ secret: null })+ await wrapper.vm.$nextTick()++ expect(wrapper.vm.code).toEqual([])+ })+ })+})+diff --git a/client/test/nuxt/two-factor-verification-modal.spec.ts b/client/test/nuxt/two-factor-verification-modal.spec.tsnew file mode 100644index 000000000..cfd79452a--- /dev/null+++ b/client/test/nuxt/two-factor-verification-modal.spec.ts@@ -0,0 +1,240 @@+import { describe, it, expect, beforeEach, vi } from 'vitest'+import { mount } from '@vue/test-utils'+import TwoFactorVerificationModal from '~/components/pages/auth/TwoFactorVerificationModal.vue'++// Mock the API+vi.mock('~/api/auth', () => ({+ authApi: {+ twoFactor: {+ verify: vi.fn(),+ },+ },+}))++describe('TwoFactorVerificationModal', () => {+ let authApi++ beforeEach(async () => {+ // Import mocked API+ const apiModule = await import('~/api/auth')+ authApi = apiModule.authApi++ // Reset mocks+ vi.clearAllMocks()+ })++ const createWrapper = (props = {}) => {+ return mount(TwoFactorVerificationModal, {+ props: {+ show: true,+ pendingAuthToken: 'test-token-123',+ ...props,+ },+ global: {+ stubs: {+ UModal: {+ template: '<div class="modal"><slot name="header" /><slot name="body" /><slot name="footer" /></div>',+ props: ['open', 'dismissible'],+ },+ UPinInput: {+ template: '<input type="text" data-testid="pin-input" />',+ props: ['modelValue', 'length', 'type', 'otp', 'autofocus', 'size', 'highlight'],+ emits: ['update:modelValue', 'complete'],+ },+ UAlert: {+ template: '<div class="alert" v-if="description">{{ description }}</div>',+ props: ['color', 'variant', 'description'],+ },+ UButton: {+ template: '<button><slot /></button>',+ props: ['variant', 'size', 'color', 'block', 'loading'],+ emits: ['click'],+ },+ TextInput: {+ template: '<input data-testid="recovery-input" />',+ props: ['modelValue', 'label', 'placeholder'],+ emits: ['update:modelValue', 'keyup.enter'],+ },+ VTransition: {+ template: '<div><slot /></div>',+ props: ['name'],+ },+ },+ },+ })+ }++ describe('Rendering', () => {+ it('should render modal when show is true and pendingAuthToken exists', () => {+ const wrapper = createWrapper()+ expect(wrapper.exists()).toBe(true)+ expect(wrapper.find('.modal').exists()).toBe(true)+ })++ it('should render modal when show is false', () => {+ const wrapper = createWrapper({ show: false })+ expect(wrapper.exists()).toBe(true)+ })++ it('should render modal when pendingAuthToken is missing', () => {+ const wrapper = createWrapper({ pendingAuthToken: null })+ expect(wrapper.exists()).toBe(true)+ })+ })++ describe('Code Verification', () => {+ it('should call verify API when handleComplete is called with valid code', async () => {+ const wrapper = createWrapper()++ authApi.twoFactor.verify.mockResolvedValue({+ token: 'verified-token',+ user: { id: 1 },+ })++ // Call the method directly+ await wrapper.vm.handleComplete(['1', '2', '3', '4', '5', '6'])++ await wrapper.vm.$nextTick()+ await new Promise(resolve => setTimeout(resolve, 100))++ expect(authApi.twoFactor.verify).toHaveBeenCalledWith({+ pending_auth_token: 'test-token-123',+ code: '123456',+ })+ })++ it('should not verify if code is invalid', async () => {+ const wrapper = createWrapper()++ // Try with invalid code (not 6 digits)+ await wrapper.vm.handleComplete(['1', '2', '3'])++ expect(authApi.twoFactor.verify).not.toHaveBeenCalled()+ })++ it('should emit verified event on successful verification', async () => {+ const wrapper = createWrapper()++ const response = {+ token: 'verified-token',+ user: { id: 1 },+ }+ authApi.twoFactor.verify.mockResolvedValue(response)++ await wrapper.vm.handleComplete(['1', '2', '3', '4', '5', '6'])+ await wrapper.vm.$nextTick()+ await new Promise(resolve => setTimeout(resolve, 100))++ expect(wrapper.emitted('verified')).toBeTruthy()+ expect(wrapper.emitted('verified')[0]).toEqual([response])+ })+ })++ describe('Error Handling', () => {+ it('should handle API errors with response data', async () => {+ const wrapper = createWrapper()++ authApi.twoFactor.verify.mockRejectedValue({+ response: {+ _data: {+ message: 'Invalid code',+ },+ },+ })++ await wrapper.vm.handleComplete(['1', '2', '3', '4', '5', '6'])+ await wrapper.vm.$nextTick()+ await new Promise(resolve => setTimeout(resolve, 100))++ expect(wrapper.vm.error).toBe('Invalid code')+ })++ it('should handle network errors gracefully', async () => {+ const wrapper = createWrapper()++ authApi.twoFactor.verify.mockRejectedValue(new Error('Network error'))++ await wrapper.vm.handleComplete(['1', '2', '3', '4', '5', '6'])+ await wrapper.vm.$nextTick()+ await new Promise(resolve => setTimeout(resolve, 100))++ expect(wrapper.vm.error).toContain('Unable to verify code')+ })++ it('should show error when pendingAuthToken is missing', async () => {+ const wrapper = createWrapper({ pendingAuthToken: null })++ await wrapper.vm.verifyCode('123456')++ expect(wrapper.vm.error).toContain('Authentication session expired')+ expect(authApi.twoFactor.verify).not.toHaveBeenCalled()+ })+ })++ describe('Recovery Code', () => {+ it('should verify recovery code using verifyCode method', async () => {+ const wrapper = createWrapper()++ authApi.twoFactor.verify.mockResolvedValue({+ token: 'verified-token',+ user: { id: 1 },+ })++ // Call verifyCode directly with recovery code (this is what verifyRecoveryCode does internally)+ // verifyCode validates the code format, so we need a valid format+ await wrapper.vm.verifyCode('123456')++ await wrapper.vm.$nextTick()+ await new Promise(resolve => setTimeout(resolve, 100))++ // Should call verify+ expect(authApi.twoFactor.verify).toHaveBeenCalled()+ })+ })++ describe('Cancel', () => {+ it('should emit cancel event when handleCancel is called', () => {+ const wrapper = createWrapper()++ wrapper.vm.handleCancel()++ expect(wrapper.emitted('cancel')).toBeTruthy()+ })++ it('should clear state on cancel', () => {+ const wrapper = createWrapper()++ // Set some state+ wrapper.vm.code = ['1', '2', '3']+ wrapper.vm.recoveryCode = 'test'+ wrapper.vm.showRecoveryCode = true++ wrapper.vm.handleCancel()++ expect(wrapper.vm.code).toEqual([])+ expect(wrapper.vm.recoveryCode).toBe('')+ expect(wrapper.vm.showRecoveryCode).toBe(false)+ })+ })++ describe('State Management', () => {+ it('should reset state when modal opens', async () => {+ const wrapper = createWrapper({ show: false })++ // Set some state+ wrapper.vm.error = 'Some error'+ wrapper.vm.code = ['1', '2', '3']++ // Open modal+ await wrapper.setProps({ show: true })+ await wrapper.vm.$nextTick()++ // State should be reset (watch handler runs)+ // Note: watch runs on next tick, so we need to wait+ await new Promise(resolve => setTimeout(resolve, 50))++ expect(wrapper.vm.error).toBe(null)+ expect(wrapper.vm.code).toEqual([])+ })+ })+})diff --git a/client/vitest.config.ts b/client/vitest.config.tsindex 2186d9917..2f1de3806 100644--- a/client/vitest.config.ts+++ b/client/vitest.config.ts@@ -1,7 +1,14 @@import { defineConfig } from 'vitest/config'import { defineVitestProject } from '@nuxt/test-utils/config'+import { resolve } from 'path'export default defineConfig({+ resolve: {+ alias: {+ '~': resolve(__dirname, '.'),+ '~/': resolve(__dirname, './'),+ },+ },test: {globals: true,projects: [