How to fix mfa_factor_not_found: MFA factor could not be found in Supabase

async function checkExistingFactors() {
  try {
    const { data: factors, error } = await supabase.auth.mfa.listFactors();

    if (error) {
      console.error('Failed to list factors:', error);
      return;
    }

    console.log('TOTP factors:', factors.totp);
    console.log('Phone factors:', factors.phone);
    console.log('All factors:', factors.all);

    // Check for unverified factors
    const unverified = factors.all.filter(f => f.status !== 'verified');
    console.log('Unverified factors:', unverified.length);

    return factors;
  } catch (err) {
    console.error('Error listing factors:', err);
  }
}

// Call this before enrollment
const currentFactors = await checkExistingFactors();

async function cleanupUnverifiedFactors() {
  try {
    const { data: factors, error } = await supabase.auth.mfa.listFactors();

    if (error) {
      console.error('Failed to list factors:', error);
      return;
    }

    // Find unverified factors
    const unverified = factors.all.filter(f => f.status !== 'verified');

    if (unverified.length === 0) {
      console.log('No unverified factors to clean up');
      return;
    }

    console.log('Cleaning up', unverified.length, 'unverified factors...');

    // Unenroll each unverified factor
    for (const factor of unverified) {
      const { error: unenrollError } = await supabase.auth.mfa.unenroll({
        factorId: factor.id
      });

      if (unenrollError) {
        console.error('Failed to unenroll factor', factor.id, ':', unenrollError);
      } else {
        console.log('Unenrolled factor:', factor.id);
      }
    }

    console.log('Cleanup complete');
  } catch (err) {
    console.error('Error cleaning up factors:', err);
  }
}

// Call before attempting new enrollment
await cleanupUnverifiedFactors();

async function completeMfaEnrollment() {
  try {
    // Step 1: Initiate enrollment
    const { data: enrollData, error: enrollError } = await supabase.auth.mfa.enroll({
      factorType: 'totp',
      friendlyName: 'My Authenticator App'
    });

    if (enrollError) {
      console.error('Enrollment failed:', enrollError.message);
      return;
    }

    console.log('Enrollment initiated. Factor ID:', enrollData.id);

    // IMPORTANT: Store the factor ID and secret temporarily
    // Do NOT reload the page or lose this session

    // Step 2: Display QR code to user
    const qrCode = enrollData.totp.qr_code;
    const secret = enrollData.totp.secret;

    console.log('Scan this QR code with your authenticator app:');
    console.log(qrCode);
    console.log('Or enter this secret:', secret);

    // Step 3: Wait for user to scan and get a code
    // This MUST happen in the same session without page reload
    const userCode = prompt('Enter the 6-digit code from your authenticator app:');

    if (!userCode) {
      console.error('User cancelled enrollment');
      // Clean up the unverified factor
      await supabase.auth.mfa.unenroll({ factorId: enrollData.id });
      return;
    }

    // Step 4: Create a challenge for verification
    const { data: challengeData, error: challengeError } =
      await supabase.auth.mfa.challenge({ factorId: enrollData.id });

    if (challengeError) {
      console.error('Challenge creation failed:', challengeError.message);
      return;
    }

    // Step 5: Verify the enrollment
    const { data: verifyData, error: verifyError } = await supabase.auth.mfa.verify({
      factorId: enrollData.id,
      challengeId: challengeData.id,
      code: userCode
    });

    if (verifyError) {
      console.error('Verification failed:', verifyError.message);
      // Clean up the unverified factor
      await supabase.auth.mfa.unenroll({ factorId: enrollData.id });
      return;
    }

    console.log('MFA enrollment successful!');
    console.log('Session updated:', verifyData);
  } catch (err) {
    console.error('MFA enrollment exception:', err);
  }
}

async function simpleMfaEnrollment() {
  try {
    // Step 1: Enroll the factor
    const { data: enrollData, error: enrollError } = await supabase.auth.mfa.enroll({
      factorType: 'totp',
      friendlyName: 'My Authenticator'
    });

    if (enrollError) {
      console.error('Enrollment failed:', enrollError);
      return;
    }

    // Step 2: Display QR code
    console.log('QR Code:', enrollData.totp.qr_code);
    const userCode = prompt('Enter code from authenticator:');

    // Step 3: Use challengeAndVerify for one-step verification
    const { data, error } = await supabase.auth.mfa.challengeAndVerify({
      factorId: enrollData.id,
      code: userCode
    });

    if (error) {
      console.error('Verification failed:', error.message);
      // Clean up unverified factor
      await supabase.auth.mfa.unenroll({ factorId: enrollData.id });
      return;
    }

    console.log('MFA enrollment complete!');
    console.log('Session:', data.session);
  } catch (err) {
    console.error('Error:', err);
  }
}

async function robustMfaVerification(factorId, code) {
  try {
    // First, verify the factor still exists
    const { data: factors, error: listError } = await supabase.auth.mfa.listFactors();

    if (listError) {
      throw new Error('Failed to list factors: ' + listError.message);
    }

    const factorExists = factors.all.some(f => f.id === factorId);

    if (!factorExists) {
      console.error('Factor not found. Available factors:', factors.all.length);

      // If no factors available, suggest re-enrollment
      if (factors.all.length === 0) {
        throw new Error('No MFA factors found. Please enroll again.');
      }

      // If other factors exist, suggest using them
      throw new Error('The selected factor no longer exists. Please select another factor or re-enroll.');
    }

    // Proceed with verification
    const { data: challengeData, error: challengeError } =
      await supabase.auth.mfa.challenge({ factorId });

    if (challengeError) {
      console.error('Challenge failed:', challengeError.message);
      throw challengeError;
    }

    const { data, error } = await supabase.auth.mfa.verify({
      factorId,
      challengeId: challengeData.id,
      code
    });

    if (error) {
      console.error('Verification failed:', error.message);
      throw error;
    }

    return { success: true, data };
  } catch (err) {
    console.error('MFA verification error:', err.message);
    return {
      success: false,
      error: err.message,
      needsReenroll: err.message.includes('not found')
    };
  }
}

// Using localStorage (for non-sensitive development)
async function startEnrollmentWithPersistence() {
  const { data: enrollData, error } = await supabase.auth.mfa.enroll({
    factorType: 'totp'
  });

  if (error) {
    console.error('Enrollment failed:', error);
    return;
  }

  // Store temporarily (clear after verification or timeout)
  sessionStorage.setItem('mfa_enrollment', JSON.stringify({
    factorId: enrollData.id,
    secret: enrollData.totp.secret,
    qrCode: enrollData.totp.qr_code,
    timestamp: Date.now()
  }));

  // Navigate to confirmation page
  window.location.href = '/mfa/confirm';
}

// On the confirmation page
async function completeEnrollmentWithRetrievedState() {
  const stored = sessionStorage.getItem('mfa_enrollment');

  if (!stored) {
    console.error('Enrollment state lost. Please start again.');
    return;
  }

  const { factorId, timestamp } = JSON.parse(stored);

  // Check timeout (e.g., 5 minutes)
  if (Date.now() - timestamp > 5 * 60 * 1000) {
    console.error('Enrollment session expired. Please start again.');
    sessionStorage.removeItem('mfa_enrollment');
    return;
  }

  const userCode = prompt('Enter code from authenticator:');

  const { data, error } = await supabase.auth.mfa.challengeAndVerify({
    factorId,
    code: userCode
  });

  if (error) {
    console.error('Verification failed:', error);
    // Keep state for retry
    return;
  }

  // Clear state on success
  sessionStorage.removeItem('mfa_enrollment');
  console.log('Enrollment complete!');
}