[Integration] WGDashboard

[botagas]

This would greatly enhance servers that are oriented towards safety and privacy.
The way this would work is very simple:

• Wizarr only has to pass the username to WGDashboard using its API. This will create a WireGuard client config.
• Wizarr would provide the QR code and supply the client config file to the user.

The way to implement that is also pretty straightforward. Firstly, you have to set up some variables to be able to access the API:

• WGDASHBOARD_URL: this is the URL:PORT of the WGDashboard instance;
• API_KEY: this is created in WGDashboard;
• WGDASHBOARD_CONFIG: this is the server config name in wgdashboard (supports multiple configs);
• (Optional) WG_DNS_SERVERS, WG_ALLOWED_IPS, WG_KEEPALIVE, WG_MTU, etc.: we can preconfigure some vars if the admin wants to;

Then the process is as follows:

1. During onboarding, Wizarr has the username and password that the user has chosen for their Jellyfin account - we can use the username to create a config. During registration, we can verify if an identically named config already exists by using the following endpoint (if wgdashboard is configured in Wizarr):

{{server}}/api/downloadAllPeers/wg-external

An example in Python:

async with aiohttp.ClientSession() as session:
    headers = {'wg-dashboard-apikey': api_key}
    
    # First, try to find existing peer by checking the peers list using downloadAllPeers
    peers_url = f"{dashboard_url}/api/downloadAllPeers/{wg_config}"
    async with session.get(peers_url, headers=headers) as response:
        if response.status == 200:
            peers_result = await response.json()
            if peers_result.get('status'):
                peers = peers_result.get('data', [])
                
                # Look for existing peer with matching fileName (which is the peer name)
                for peer in peers:
                    if peer.get('fileName') == self.username:
                        # For existing peers, downloadAllPeers already contains the config file
                        config_data = peer.get('file')
                        if config_data:
                            logger.info(f"Retrieved existing WireGuard config for {self.username}")
                            return {'success': True, 'config': config_data}
                        else:
                            logger.error(f"No config file data in peer data for {self.username}")
                        break
                
                # If we reach here, peer doesn't exist, so create it
                logger.info(f"WireGuard peer {self.username} doesn't exist, creating new one")
        else:
            logger.error(f"Failed to get peers list: {response.status}")
            return None

2. We then create the config using the addPeer endpoint:

{{server}}/api/addPeers/wg-external

Which looks like so:

peer_data = {
    "bulkAdd": False,
    "name": self.username,
    "allowed_ips": [],  # Empty means auto-assign
    "private_key": "",
    "DNS": os.getenv('WG_DNS_SERVERS', ''),
    "endpoint_allowed_ip": os.getenv('WG_ALLOWED_IPS', ''),
    "keepalive": int(os.getenv('WG_KEEPALIVE', '')),
    "mtu": int(os.getenv('WG_MTU', '')),
    "preshared_key": ""
}

# Create the peer using the correct addPeers endpoint
create_url = f"{dashboard_url}/api/addPeers/{wg_config}"

3. Afterwards, we can proceed by fetching the created peer and providing it to the user. For that, we utilise this endpoint:

{{server}}/api/downloadPeer/wg-external?id=Wu%2F0xCr%2Bn%2FcaqDVKtjG%2BC9UelAvY%2FbeARX3cW1i7LUI%3D

Which can be done as follows:

create_result = await response.json()

# Get the peer ID directly from the creation response
created_peers = create_result.get('data', [])
if created_peers:
    new_peer = created_peers[0]  # First peer from the response
    peer_id = new_peer.get('id')  # This is the public key
    
    if peer_id:
        # Download the new peer's config using the ID from creation response
        encoded_peer_id = urllib.parse.quote(peer_id, safe='')
        download_url = f"{dashboard_url}/api/downloadPeer/{wg_config}?id={encoded_peer_id}"
        
        async with session.get(download_url, headers=headers) as config_response:
            if config_response.status == 200:
                config_result = await config_response.json()
                if config_result.get('status'):
                    config_data = config_result.get('data', {}).get('file')
                    if config_data:
                        logger.info(f"Retrieved new WireGuard config for {self.username}")
                        return {'success': True, 'config': config_data}

And that's it, we have what we need - config is created, and we have it, just need to provide it to the user in the web now during onboarding.

It is very simple to implement this since that's just a couple of cURL requests and a couple of fields that need to be filled out.