diff --git a/src-tauri/src/commands/controllers.rs b/src-tauri/src/commands/controllers.rs
new file mode 100644
index 0000000..2cae415
--- /dev/null
+++ b/src-tauri/src/commands/controllers.rs
@@ -0,0 +1,147 @@
+use ssh2::Session;
+use std::{
+    io::Read,
+    net::{TcpStream, ToSocketAddrs},
+    time::Duration,
+};
+
+fn run_vps_command(
+    password: &str,
+    command: &str,
+) -> Result<String, String> {
+    let address = "146.59.230.190:22";
+
+    let socket_address = address
+        .to_socket_addrs()
+        .map_err(|error| {
+            format!(
+                "failed to resolve VPS address: {}",
+                error
+            )
+        })?
+        .next()
+        .ok_or_else(|| {
+            format!(
+                "failed to resolve VPS address {}",
+                address
+            )
+        })?;
+
+    let tcp = TcpStream::connect_timeout(
+        &socket_address,
+        Duration::from_secs(8),
+    )
+    .map_err(|error| {
+        format!(
+            "failed to connect to VPS SSH: {}",
+            error
+        )
+    })?;
+
+    let _ = tcp.set_read_timeout(Some(
+        Duration::from_secs(30),
+    ));
+
+    let _ = tcp.set_write_timeout(Some(
+        Duration::from_secs(30),
+    ));
+
+    let mut session = Session::new()
+        .map_err(|error| {
+            format!(
+                "failed to create VPS SSH session: {}",
+                error
+            )
+        })?;
+
+    session.set_tcp_stream(tcp);
+
+    session.handshake().map_err(|error| {
+        format!(
+            "VPS SSH handshake failed: {}",
+            error
+        )
+    })?;
+
+    session
+        .userauth_password("lr-vpn", password)
+        .map_err(|error| {
+            format!(
+                "VPS SSH authentication failed: {}",
+                error
+            )
+        })?;
+
+    if !session.authenticated() {
+        return Err(
+            "VPS SSH authentication failed"
+                .into(),
+        );
+    }
+
+    let mut channel = session
+        .channel_session()
+        .map_err(|error| {
+            format!(
+                "failed to open VPS SSH channel: {}",
+                error
+            )
+        })?;
+
+    channel
+        .exec(command)
+        .map_err(|error| {
+            format!(
+                "failed to execute VPS command: {}",
+                error
+            )
+        })?;
+
+    let mut stdout = String::new();
+
+    channel
+        .read_to_string(&mut stdout)
+        .map_err(|error| {
+            format!(
+                "failed to read VPS command output: {}",
+                error
+            )
+        })?;
+
+    channel.wait_close().ok();
+
+    let exit_status = channel
+        .exit_status()
+        .map_err(|error| {
+            format!(
+                "failed to read VPS command exit status: {}",
+                error
+            )
+        })?;
+
+    if exit_status != 0 {
+        return Err(format!(
+            "VPS command failed with exit code {}:\n{}",
+            exit_status,
+            stdout
+        ));
+    }
+
+    Ok(stdout)
+}
+
+#[tauri::command]
+pub async fn list_controller_clients(
+    password: String,
+) -> Result<String, String> {
+    if password.trim().is_empty() {
+        return Err(
+            "VPS password is required".into(),
+        );
+    }
+
+    run_vps_command(
+        &password,
+        "sudo /usr/local/sbin/lr-controllers-list",
+    )
+}
\ No newline at end of file
diff --git a/src-tauri/src/commands/mod.rs b/src-tauri/src/commands/mod.rs
index 21d8fcc..44fe54a 100644
--- a/src-tauri/src/commands/mod.rs
+++ b/src-tauri/src/commands/mod.rs
@@ -2,3 +2,4 @@ pub mod files;
 pub mod network;
 pub mod router;
 pub mod ssh;
+pub mod controllers;
\ No newline at end of file
diff --git a/src-tauri/src/commands/router.rs b/src-tauri/src/commands/router.rs
index 70299ea..6b98f86 100644
--- a/src-tauri/src/commands/router.rs
+++ b/src-tauri/src/commands/router.rs
@@ -2,17 +2,25 @@ use ssh2::Session;
 use std::process::Command;
 use std::{
     fs::File,
-    io::{ Read, Write },
-    net::{ TcpStream, ToSocketAddrs },
-    path::Path,
+    io::{Read, Write},
+    net::{TcpStream, ToSocketAddrs},
+    path::{Path, PathBuf},
     thread,
     time::Duration,
 };
+use tauri::{AppHandle, Manager};
 
 fn delay() {
     thread::sleep(Duration::from_millis(350));
 }
 
+fn resource_path(app: &AppHandle, relative_path: &str) -> Result<PathBuf, String> {
+    app.path()
+        .resource_dir()
+        .map_err(|error| format!("failed to resolve resource directory: {}", error))
+        .map(|resource_dir| resource_dir.join("resources").join(relative_path))
+}
+
 #[tauri::command]
 pub async fn detect_router(ip: String) -> Result<bool, String> {
     delay();
@@ -64,9 +72,12 @@ fn run_system_ssh(ip: &str, command: &str) -> Result<String, String> {
         return Ok(format!("{}{}", stdout, stderr));
     }
 
-    Err(
-        format!("system ssh failed with status {:?}:\n{}\n{}", output.status.code(), stderr, stdout)
-    )
+    Err(format!(
+        "system ssh failed with status {:?}:\n{}\n{}",
+        output.status.code(),
+        stderr,
+        stdout
+    ))
 }
 
 fn open_router_session(ip: &str, password: &str) -> Result<Session, String> {
@@ -78,20 +89,20 @@ fn open_router_session(ip: &str, password: &str) -> Result<Session, String> {
         .next()
         .ok_or_else(|| format!("failed to resolve router address {}", address))?;
 
-    let tcp = TcpStream::connect_timeout(&socket_address, Duration::from_secs(8)).map_err(|error|
-        format!("failed to connect to SSH on {}: {}", ip, error)
-    )?;
+    let tcp = TcpStream::connect_timeout(&socket_address, Duration::from_secs(8))
+        .map_err(|error| format!("failed to connect to SSH on {}: {}", ip, error))?;
 
     let _ = tcp.set_read_timeout(Some(Duration::from_secs(30)));
     let _ = tcp.set_write_timeout(Some(Duration::from_secs(30)));
 
-    let mut session = Session::new().map_err(|error|
-        format!("failed to create SSH session: {}", error)
-    )?;
+    let mut session =
+        Session::new().map_err(|error| format!("failed to create SSH session: {}", error))?;
 
     session.set_tcp_stream(tcp);
 
-    session.handshake().map_err(|error| format!("SSH handshake failed for {}: {}", ip, error))?;
+    session
+        .handshake()
+        .map_err(|error| format!("SSH handshake failed for {}: {}", ip, error))?;
 
     authenticate_router(&session, password).map_err(|error| format!("root@{}: {}", ip, error))?;
 
@@ -102,11 +113,10 @@ fn scp_file_from_disk(
     session: &Session,
     local_path: &str,
     remote_path: &str,
-    mode: i32
+    mode: i32,
 ) -> Result<(), String> {
-    let mut local_file = File::open(local_path).map_err(|error|
-        format!("failed to open {}: {}", local_path, error)
-    )?;
+    let mut local_file =
+        File::open(local_path).map_err(|error| format!("failed to open {}: {}", local_path, error))?;
 
     let file_size = local_file
         .metadata()
@@ -135,12 +145,7 @@ fn scp_file_from_disk(
     Ok(())
 }
 
-fn scp_string(
-    session: &Session,
-    content: &str,
-    remote_path: &str,
-    mode: i32
-) -> Result<(), String> {
+fn scp_string(session: &Session, content: &str, remote_path: &str, mode: i32) -> Result<(), String> {
     let bytes = content.as_bytes();
 
     let mut remote_file = session
@@ -260,9 +265,15 @@ pub async fn verify_router(ip: String) -> Result<bool, String> {
 }
 
 #[tauri::command]
-pub async fn upload_firmware_to_router(ip: String, password: String) -> Result<String, String> {
-    let local_firmware_path =
-        "resources/firmware/openwrt-23.05.5-zbt-we826-16m-litoral-golden-sysupgrade.bin";
+pub async fn upload_firmware_to_router(
+    app: AppHandle,
+    ip: String,
+    password: String,
+) -> Result<String, String> {
+    let local_firmware_path = resource_path(
+        &app,
+        "firmware/openwrt-23.05.5-zbt-we826-16m-litoral-golden-sysupgrade.bin",
+    )?;
 
     let remote_firmware_path = "/tmp/firmware.bin";
 
@@ -270,16 +281,11 @@ pub async fn upload_firmware_to_router(ip: String, password: String) -> Result<S
         return Err("router IP is required".into());
     }
 
-    /*
-     * FACTORY / FRESH OPENWRT PATH
-     * Uses system scp when no password is set.
-     */
-
     if password.trim().is_empty() {
         let target = format!("root@{}:{}", ip, remote_firmware_path);
+        let local_firmware_path_string = local_firmware_path.to_string_lossy().to_string();
 
-        let output = std::process::Command
-            ::new("scp")
+        let output = Command::new("scp")
             .args([
                 "-O",
                 "-o",
@@ -288,103 +294,80 @@ pub async fn upload_firmware_to_router(ip: String, password: String) -> Result<S
                 "ConnectTimeout=10",
                 "-o",
                 "StrictHostKeyChecking=accept-new",
-                local_firmware_path,
+                &local_firmware_path_string,
                 &target,
             ])
             .output()
-            .map_err(|error| { format!("failed to run system scp: {}", error) })?;
+            .map_err(|error| format!("failed to run system scp: {}", error))?;
 
         if output.status.success() {
-            return Ok(
-                format!("Firmware uploaded to {}:{} using system scp", ip, remote_firmware_path)
-            );
+            return Ok(format!(
+                "Firmware uploaded to {}:{} using system scp",
+                ip, remote_firmware_path
+            ));
         }
 
-        return Err(
-            format!(
-                "system scp failed:\n{}\n{}",
-                String::from_utf8_lossy(&output.stderr),
-                String::from_utf8_lossy(&output.stdout)
-            )
-        );
+        return Err(format!(
+            "system scp failed:\n{}\n{}",
+            String::from_utf8_lossy(&output.stderr),
+            String::from_utf8_lossy(&output.stdout)
+        ));
     }
 
-    /*
-     * PASSWORD SSH PATH
-     */
+    let session = open_router_session(&ip, &password)?;
 
-    let address = format!("{}:22", ip);
-
-    let socket_address = address
-        .to_socket_addrs()
-        .map_err(|error| { format!("failed to resolve router address: {}", error) })?
-        .next()
-        .ok_or_else(|| { format!("failed to resolve router address {}", address) })?;
-
-    let tcp = TcpStream::connect_timeout(&socket_address, Duration::from_secs(8)).map_err(|error| {
-        format!("failed to connect to SSH on {}: {}", ip, error)
-    })?;
-
-    tcp
-        .set_read_timeout(Some(Duration::from_secs(30)))
-        .map_err(|error| { format!("failed to set read timeout: {}", error) })?;
-
-    tcp
-        .set_write_timeout(Some(Duration::from_secs(30)))
-        .map_err(|error| { format!("failed to set write timeout: {}", error) })?;
-
-    let mut session = Session::new().map_err(|error| {
-        format!("failed to create SSH session: {}", error)
-    })?;
-
-    session.set_tcp_stream(tcp);
-
-    session.handshake().map_err(|error| { format!("SSH handshake failed for {}: {}", ip, error) })?;
-
-    session
-        .userauth_password("root", &password)
-        .map_err(|error| { format!("SSH authentication failed for root@{}: {}", ip, error) })?;
-
-    if !session.authenticated() {
-        return Err(format!("SSH authentication failed for root@{}", ip));
-    }
-
-    let mut local_file = File::open(local_firmware_path).map_err(|error| {
-        format!("failed to open local firmware file {}: {}", local_firmware_path, error)
+    let mut local_file = File::open(&local_firmware_path).map_err(|error| {
+        format!(
+            "failed to open local firmware file {}: {}",
+            local_firmware_path.display(),
+            error
+        )
     })?;
 
     let firmware_size = local_file
         .metadata()
-        .map_err(|error| { format!("failed to read firmware metadata: {}", error) })?
+        .map_err(|error| format!("failed to read firmware metadata: {}", error))?
         .len();
 
     let mut buffer = Vec::new();
 
     local_file
         .read_to_end(&mut buffer)
-        .map_err(|error| { format!("failed to read firmware file: {}", error) })?;
+        .map_err(|error| format!("failed to read firmware file: {}", error))?;
 
     let mut remote_file = session
         .scp_send(Path::new(remote_firmware_path), 0o644, firmware_size, None)
         .map_err(|error| {
-            format!("failed to start SCP upload to {}: {}", remote_firmware_path, error)
+            format!(
+                "failed to start SCP upload to {}: {}",
+                remote_firmware_path, error
+            )
         })?;
 
     remote_file
         .write_all(&buffer)
-        .map_err(|error| { format!("failed to upload firmware via SCP: {}", error) })?;
+        .map_err(|error| format!("failed to upload firmware via SCP: {}", error))?;
 
-    remote_file.send_eof().map_err(|error| { format!("failed to send SCP EOF: {}", error) })?;
+    remote_file
+        .send_eof()
+        .map_err(|error| format!("failed to send SCP EOF: {}", error))?;
 
-    remote_file.wait_eof().map_err(|error| { format!("failed waiting for SCP EOF: {}", error) })?;
+    remote_file
+        .wait_eof()
+        .map_err(|error| format!("failed waiting for SCP EOF: {}", error))?;
 
-    remote_file.close().map_err(|error| { format!("failed closing SCP channel: {}", error) })?;
+    remote_file
+        .close()
+        .map_err(|error| format!("failed closing SCP channel: {}", error))?;
 
     remote_file
         .wait_close()
-        .map_err(|error| { format!("failed waiting for SCP close: {}", error) })?;
+        .map_err(|error| format!("failed waiting for SCP close: {}", error))?;
 
-    Ok(format!("Firmware uploaded to {}:{} ({} bytes)", ip, remote_firmware_path, firmware_size))
+    Ok(format!(
+        "Firmware uploaded to {}:{} ({} bytes)",
+        ip, remote_firmware_path, firmware_size
+    ))
 }
 
 #[tauri::command]
@@ -399,22 +382,26 @@ pub async fn flash_router_sysupgrade(ip: String, password: String) -> Result<Str
         let output = run_system_ssh(&ip, flash_command);
 
         return match output {
-            Ok(output) =>
-                Ok(format!("sysupgrade command submitted on {} using system ssh. {}", ip, output)),
+            Ok(output) => Ok(format!(
+                "sysupgrade command submitted on {} using system ssh. {}",
+                ip, output
+            )),
             Err(error) => {
                 let lowered = error.to_lowercase();
 
-                if
-                    lowered.contains("commencing upgrade") ||
-                    lowered.contains("closing all shell sessions") ||
-                    lowered.contains("connection failed") ||
-                    lowered.contains("connection reset") ||
-                    lowered.contains("broken pipe") ||
-                    lowered.contains("closed") ||
-                    lowered.contains("disconnect") ||
-                    lowered.contains("sysupgrade")
+                if lowered.contains("commencing upgrade")
+                    || lowered.contains("closing all shell sessions")
+                    || lowered.contains("connection failed")
+                    || lowered.contains("connection reset")
+                    || lowered.contains("broken pipe")
+                    || lowered.contains("closed")
+                    || lowered.contains("disconnect")
+                    || lowered.contains("sysupgrade")
                 {
-                    Ok(format!("sysupgrade started on {}; SSH disconnected as expected.", ip))
+                    Ok(format!(
+                        "sysupgrade started on {}; SSH disconnected as expected.",
+                        ip
+                    ))
                 } else {
                     Err(error)
                 }
@@ -422,40 +409,15 @@ pub async fn flash_router_sysupgrade(ip: String, password: String) -> Result<Str
         };
     }
 
-    let address = format!("{}:22", ip);
-
-    let socket_address = address
-        .to_socket_addrs()
-        .map_err(|error| { format!("failed to resolve router address: {}", error) })?
-        .next()
-        .ok_or_else(|| { format!("failed to resolve router address {}", address) })?;
-
-    let tcp = TcpStream::connect_timeout(&socket_address, Duration::from_secs(8)).map_err(|error| {
-        format!("failed to connect to SSH on {}: {}", ip, error)
-    })?;
-
-    tcp.set_read_timeout(Some(Duration::from_secs(8))).ok();
-    tcp.set_write_timeout(Some(Duration::from_secs(8))).ok();
-
-    let mut session = Session::new().map_err(|error| {
-        format!("failed to create SSH session: {}", error)
-    })?;
-
-    session.set_tcp_stream(tcp);
-
-    session.handshake().map_err(|error| { format!("SSH handshake failed for {}: {}", ip, error) })?;
-
-    authenticate_router(&session, &password).map_err(|error| {
-        format!("root@{}: {}", ip, error)
-    })?;
+    let session = open_router_session(&ip, &password)?;
 
     let mut channel = session
         .channel_session()
-        .map_err(|error| { format!("failed to open SSH channel: {}", error) })?;
+        .map_err(|error| format!("failed to open SSH channel: {}", error))?;
 
     channel
         .exec(flash_command)
-        .map_err(|error| { format!("failed to start sysupgrade: {}", error) })?;
+        .map_err(|error| format!("failed to start sysupgrade: {}", error))?;
 
     let mut output = String::new();
     let _ = channel.read_to_string(&mut output);
@@ -463,17 +425,20 @@ pub async fn flash_router_sysupgrade(ip: String, password: String) -> Result<Str
 
     let lowered = output.to_lowercase();
 
-    if
-        lowered.contains("commencing upgrade") ||
-        lowered.contains("closing all shell sessions") ||
-        lowered.contains("sysupgrade")
+    if lowered.contains("commencing upgrade")
+        || lowered.contains("closing all shell sessions")
+        || lowered.contains("sysupgrade")
     {
-        return Ok(
-            format!("sysupgrade started on {}; router should reboot shortly. {}", ip, output)
-        );
+        return Ok(format!(
+            "sysupgrade started on {}; router should reboot shortly. {}",
+            ip, output
+        ));
     }
 
-    Ok(format!("sysupgrade command submitted on {}. Router should reboot shortly. {}", ip, output))
+    Ok(format!(
+        "sysupgrade command submitted on {}. Router should reboot shortly. {}",
+        ip, output
+    ))
 }
 
 #[tauri::command]
@@ -489,14 +454,10 @@ pub async fn reconnect_router_after_flash(ip: String, password: String) -> Resul
         if password.trim().is_empty() {
             match run_system_ssh(&ip, "ubus call system board") {
                 Ok(output) => {
-                    return Ok(
-                        format!(
-                            "Router reconnected after flash on attempt {}/{} using system ssh.\n{}",
-                            attempt,
-                            max_attempts,
-                            output
-                        )
-                    );
+                    return Ok(format!(
+                        "Router reconnected after flash on attempt {}/{} using system ssh.\n{}",
+                        attempt, max_attempts, output
+                    ));
                 }
                 Err(_) => {
                     thread::sleep(wait_between_attempts);
@@ -505,93 +466,24 @@ pub async fn reconnect_router_after_flash(ip: String, password: String) -> Resul
             }
         }
 
-        let address = format!("{}:22", ip);
-
-        let socket_address = match address.to_socket_addrs() {
-            Ok(mut addresses) =>
-                match addresses.next() {
-                    Some(socket_address) => socket_address,
-                    None => {
-                        thread::sleep(wait_between_attempts);
-                        continue;
-                    }
+        match open_router_session(&ip, &password) {
+            Ok(session) => match run_ssh_command(&session, "ubus call system board") {
+                Ok(output) => {
+                    return Ok(format!(
+                        "Router reconnected after flash on attempt {}/{}.\n{}",
+                        attempt, max_attempts, output
+                    ));
                 }
-            Err(_) => {
-                thread::sleep(wait_between_attempts);
-                continue;
-            }
-        };
-
-        let tcp = match TcpStream::connect_timeout(&socket_address, Duration::from_secs(4)) {
-            Ok(tcp) => tcp,
-            Err(_) => {
-                thread::sleep(wait_between_attempts);
-                continue;
-            }
-        };
-
-        let _ = tcp.set_read_timeout(Some(Duration::from_secs(8)));
-        let _ = tcp.set_write_timeout(Some(Duration::from_secs(8)));
-
-        let mut session = match Session::new() {
-            Ok(session) => session,
-            Err(_) => {
-                thread::sleep(wait_between_attempts);
-                continue;
-            }
-        };
-
-        session.set_tcp_stream(tcp);
-
-        if session.handshake().is_err() {
-            thread::sleep(wait_between_attempts);
-            continue;
+                Err(_) => thread::sleep(wait_between_attempts),
+            },
+            Err(_) => thread::sleep(wait_between_attempts),
         }
-
-        if authenticate_router(&session, &password).is_err() {
-            thread::sleep(wait_between_attempts);
-            continue;
-        }
-
-        let mut channel = match session.channel_session() {
-            Ok(channel) => channel,
-            Err(_) => {
-                thread::sleep(wait_between_attempts);
-                continue;
-            }
-        };
-
-        if channel.exec("ubus call system board").is_err() {
-            thread::sleep(wait_between_attempts);
-            continue;
-        }
-
-        let mut output = String::new();
-
-        if channel.read_to_string(&mut output).is_err() {
-            thread::sleep(wait_between_attempts);
-            continue;
-        }
-
-        let _ = channel.wait_close();
-
-        return Ok(
-            format!(
-                "Router reconnected after flash on attempt {}/{}.\n{}",
-                attempt,
-                max_attempts,
-                output
-            )
-        );
     }
 
-    Err(
-        format!(
-            "Router did not become reachable over SSH at {} after {} attempts. Replug Ethernet and retry.",
-            ip,
-            max_attempts
-        )
-    )
+    Err(format!(
+        "Router did not become reachable over SSH at {} after {} attempts. Replug Ethernet and retry.",
+        ip, max_attempts
+    ))
 }
 
 #[tauri::command]
@@ -604,66 +496,28 @@ pub async fn check_router_after_flash(ip: String, password: String) -> Result<St
         return run_system_ssh(&ip, "ubus call system board");
     }
 
-    let address = format!("{}:22", ip);
-
-    let socket_address = address
-        .to_socket_addrs()
-        .map_err(|error| format!("failed to resolve router address: {}", error))?
-        .next()
-        .ok_or_else(|| format!("failed to resolve router address {}", address))?;
-
-    let tcp = TcpStream::connect_timeout(&socket_address, Duration::from_secs(4)).map_err(|error|
-        format!("SSH not ready at {}: {}", ip, error)
-    )?;
-
-    let _ = tcp.set_read_timeout(Some(Duration::from_secs(8)));
-    let _ = tcp.set_write_timeout(Some(Duration::from_secs(8)));
-
-    let mut session = Session::new().map_err(|error|
-        format!("failed to create SSH session: {}", error)
-    )?;
-
-    session.set_tcp_stream(tcp);
-
-    session.handshake().map_err(|error| format!("SSH handshake failed: {}", error))?;
-
-    authenticate_router(&session, &password).map_err(|error| format!("root@{}: {}", ip, error))?;
-
-    let mut channel = session
-        .channel_session()
-        .map_err(|error| format!("failed to open SSH channel: {}", error))?;
-
-    channel
-        .exec("ubus call system board")
-        .map_err(|error| format!("failed to run ubus: {}", error))?;
-
-    let mut output = String::new();
-
-    channel
-        .read_to_string(&mut output)
-        .map_err(|error| format!("failed to read router info: {}", error))?;
-
-    let _ = channel.wait_close();
-
-    Ok(output)
+    let session = open_router_session(&ip, &password)?;
+    run_ssh_command(&session, "ubus call system board")
 }
 
 #[tauri::command]
 pub async fn upload_provisioning_bundle(
+    app: AppHandle,
     ip: String,
     password: String,
-    env_content: String
+    env_content: String,
 ) -> Result<String, String> {
     if ip.trim().is_empty() {
         return Err("router IP is required".into());
     }
 
-    let local_script_path = "resources/provisioning/provision.sh";
+    let local_script_path = resource_path(&app, "provisioning/provision.sh")?;
     let remote_script_path = "/tmp/provision.sh";
     let remote_env_path = "/tmp/router.env";
 
     if password.trim().is_empty() {
         let script_target = format!("root@{}:{}", ip, remote_script_path);
+        let local_script_path_string = local_script_path.to_string_lossy().to_string();
 
         let script_upload = Command::new("scp")
             .args([
@@ -676,37 +530,41 @@ pub async fn upload_provisioning_bundle(
                 "StrictHostKeyChecking=no",
                 "-o",
                 "UserKnownHostsFile=NUL",
-                local_script_path,
+                &local_script_path_string,
                 &script_target,
             ])
             .output()
             .map_err(|error| format!("failed to run scp for provision.sh: {}", error))?;
 
         if !script_upload.status.success() {
-            return Err(
-                format!(
-                    "failed to upload provision.sh:\n{}\n{}",
-                    String::from_utf8_lossy(&script_upload.stderr),
-                    String::from_utf8_lossy(&script_upload.stdout)
-                )
-            );
+            return Err(format!(
+                "failed to upload provision.sh:\n{}\n{}",
+                String::from_utf8_lossy(&script_upload.stderr),
+                String::from_utf8_lossy(&script_upload.stdout)
+            ));
         }
 
         let env_command = format!(
             "cat > {} <<'EOF'\n{}\nEOF\nchmod +x {}",
-            remote_env_path,
-            env_content,
-            remote_script_path
+            remote_env_path, env_content, remote_script_path
         );
 
         run_system_ssh(&ip, &env_command)?;
 
-        return Ok(format!("uploaded provision.sh and router.env to {} using system ssh/scp", ip));
+        return Ok(format!(
+            "uploaded provision.sh and router.env to {} using system ssh/scp",
+            ip
+        ));
     }
 
     let session = open_router_session(&ip, &password)?;
 
-    scp_file_from_disk(&session, local_script_path, remote_script_path, 0o755)?;
+    scp_file_from_disk(
+        &session,
+        local_script_path.to_string_lossy().as_ref(),
+        remote_script_path,
+        0o755,
+    )?;
 
     scp_string(&session, &env_content, remote_env_path, 0o600)?;
 
@@ -716,16 +574,21 @@ pub async fn upload_provisioning_bundle(
 }
 
 #[tauri::command]
-pub async fn upload_udp2raw_setup_script(ip: String, password: String) -> Result<String, String> {
+pub async fn upload_udp2raw_setup_script(
+    app: AppHandle,
+    ip: String,
+    password: String,
+) -> Result<String, String> {
     if ip.trim().is_empty() {
         return Err("router IP is required".into());
     }
 
-    let local_script_path = "resources/udp2raw/setup_udp2raw.sh";
+    let local_script_path = resource_path(&app, "udp2raw/setup_udp2raw.sh")?;
     let remote_script_path = "/tmp/setup_udp2raw.sh";
 
     if password.trim().is_empty() {
         let target = format!("root@{}:{}", ip, remote_script_path);
+        let local_script_path_string = local_script_path.to_string_lossy().to_string();
 
         let output = Command::new("scp")
             .args([
@@ -738,20 +601,18 @@ pub async fn upload_udp2raw_setup_script(ip: String, password: String) -> Result
                 "StrictHostKeyChecking=no",
                 "-o",
                 "UserKnownHostsFile=NUL",
-                local_script_path,
+                &local_script_path_string,
                 &target,
             ])
             .output()
             .map_err(|error| format!("failed to run scp for setup_udp2raw.sh: {}", error))?;
 
         if !output.status.success() {
-            return Err(
-                format!(
-                    "failed to upload setup_udp2raw.sh:\n{}\n{}",
-                    String::from_utf8_lossy(&output.stderr),
-                    String::from_utf8_lossy(&output.stdout)
-                )
-            );
+            return Err(format!(
+                "failed to upload setup_udp2raw.sh:\n{}\n{}",
+                String::from_utf8_lossy(&output.stderr),
+                String::from_utf8_lossy(&output.stdout)
+            ));
         }
 
         run_system_ssh(&ip, "chmod +x /tmp/setup_udp2raw.sh")?;
@@ -761,7 +622,12 @@ pub async fn upload_udp2raw_setup_script(ip: String, password: String) -> Result
 
     let session = open_router_session(&ip, &password)?;
 
-    scp_file_from_disk(&session, local_script_path, remote_script_path, 0o755)?;
+    scp_file_from_disk(
+        &session,
+        local_script_path.to_string_lossy().as_ref(),
+        remote_script_path,
+        0o755,
+    )?;
 
     run_ssh_command(&session, "chmod +x /tmp/setup_udp2raw.sh")?;
 
@@ -791,8 +657,7 @@ pub async fn check_udp2raw_router_status(ip: String, password: String) -> Result
         return Err("router IP is required".into());
     }
 
-    let command =
-        r#"
+    let command = r#"
     echo "== udp2raw binary =="
     if command -v udp2raw >/dev/null 2>&1; then
     command -v udp2raw
@@ -899,12 +764,7 @@ pub async fn test_udp2raw_tunnel(ip: String, password: String) -> Result<String,
                 return run_ssh_command(&session, command);
             }
             Err(error) => {
-                last_error = format!(
-                    "SSH attempt {}/5 failed: {}",
-                    attempt,
-                    error
-                );
-
+                last_error = format!("SSH attempt {}/5 failed: {}", attempt, error);
                 thread::sleep(Duration::from_secs(2));
             }
         }
@@ -914,16 +774,21 @@ pub async fn test_udp2raw_tunnel(ip: String, password: String) -> Result<String,
 }
 
 #[tauri::command]
-pub async fn upload_udp2raw_binary(ip: String, password: String) -> Result<String, String> {
+pub async fn upload_udp2raw_binary(
+    app: AppHandle,
+    ip: String,
+    password: String,
+) -> Result<String, String> {
     if ip.trim().is_empty() {
         return Err("router IP is required".into());
     }
 
-    let local_binary_path = "resources/udp2raw/udp2raw";
+    let local_binary_path = resource_path(&app, "udp2raw/udp2raw")?;
     let remote_binary_path = "/usr/bin/udp2raw";
 
     if password.trim().is_empty() {
         let target = format!("root@{}:{}", ip, remote_binary_path);
+        let local_binary_path_string = local_binary_path.to_string_lossy().to_string();
 
         let output = Command::new("scp")
             .args([
@@ -936,25 +801,23 @@ pub async fn upload_udp2raw_binary(ip: String, password: String) -> Result<Strin
                 "StrictHostKeyChecking=no",
                 "-o",
                 "UserKnownHostsFile=NUL",
-                local_binary_path,
+                &local_binary_path_string,
                 &target,
             ])
             .output()
-            .map_err(|error| { format!("failed to run scp for udp2raw binary: {}", error) })?;
+            .map_err(|error| format!("failed to run scp for udp2raw binary: {}", error))?;
 
         if !output.status.success() {
-            return Err(
-                format!(
-                    "failed to upload udp2raw binary:\n{}\n{}",
-                    String::from_utf8_lossy(&output.stderr),
-                    String::from_utf8_lossy(&output.stdout)
-                )
-            );
+            return Err(format!(
+                "failed to upload udp2raw binary:\n{}\n{}",
+                String::from_utf8_lossy(&output.stderr),
+                String::from_utf8_lossy(&output.stdout)
+            ));
         }
 
         run_system_ssh(
             &ip,
-            "chmod +x /usr/bin/udp2raw && /usr/bin/udp2raw --help >/dev/null 2>&1 || true"
+            "chmod +x /usr/bin/udp2raw && /usr/bin/udp2raw --help >/dev/null 2>&1 || true",
         )?;
 
         return Ok("uploaded udp2raw binary to /usr/bin/udp2raw".into());
@@ -962,9 +825,17 @@ pub async fn upload_udp2raw_binary(ip: String, password: String) -> Result<Strin
 
     let session = open_router_session(&ip, &password)?;
 
-    scp_file_from_disk(&session, local_binary_path, remote_binary_path, 0o755)?;
+    scp_file_from_disk(
+        &session,
+        local_binary_path.to_string_lossy().as_ref(),
+        remote_binary_path,
+        0o755,
+    )?;
 
-    run_ssh_command(&session, "chmod +x /usr/bin/udp2raw && ls -l /usr/bin/udp2raw")?;
+    run_ssh_command(
+        &session,
+        "chmod +x /usr/bin/udp2raw && ls -l /usr/bin/udp2raw",
+    )?;
 
     Ok("uploaded udp2raw binary to /usr/bin/udp2raw".into())
-}
+}
\ No newline at end of file
diff --git a/src-tauri/src/lib.rs b/src-tauri/src/lib.rs
index cf0ba95..7cb883d 100644
--- a/src-tauri/src/lib.rs
+++ b/src-tauri/src/lib.rs
@@ -23,6 +23,7 @@ use commands::{
         upload_udp2raw_binary
     },
     ssh::{ inspect_router_with_password, probe_router_ssh, remove_known_host },
+    controllers::{ list_controller_clients}
 };
 
 #[cfg_attr(mobile, tauri::mobile_entry_point)]
@@ -54,7 +55,8 @@ pub fn run() {
                 run_udp2raw_setup,
                 test_udp2raw_tunnel,
                 check_udp2raw_router_status,
-                upload_udp2raw_binary
+                upload_udp2raw_binary,
+                list_controller_clients
             ]
         )
         .run(tauri::generate_context!())
diff --git a/src-tauri/tauri.conf.json b/src-tauri/tauri.conf.json
index 763d8ac..ffba255 100644
--- a/src-tauri/tauri.conf.json
+++ b/src-tauri/tauri.conf.json
@@ -30,6 +30,9 @@
     "targets": "all",
     "icon": [
       "icons/icon.ico"
+    ],
+    "resources": [
+      "resources/**/*"
     ]
   }
 }
\ No newline at end of file
diff --git a/src/app/routes.tsx b/src/app/routes.tsx
index 7a47708..54d34d7 100644
--- a/src/app/routes.tsx
+++ b/src/app/routes.tsx
@@ -18,6 +18,7 @@ import { BackendSettings } from '@/components/settings/BackendSettings';
 import { ActivityLogs } from '@/components/activity/ActivityLogs';
 import { Card } from '@/components/ui/Card';
 import { Udp2rawConfig } from '@/components/udp2raw/Udp2rawConfig';
+import { ControllersRoute } from '@/components/controllers/ControllersRoute';
 
 import { vpnApi } from '@/services/vpnApi';
 import { vpsApi } from '@/services/vpsApi';
@@ -281,6 +282,10 @@ export function RouteView({
     return <DashboardRoute />;
   }
 
+  if (active === 'Controladores') {
+    return <ControllersRoute />;
+  }
+
   if (active === 'Provisionamento') {
     return <ProvisioningWizard />;
   }
diff --git a/src/components/controllers/ControllersRoute.tsx b/src/components/controllers/ControllersRoute.tsx
new file mode 100644
index 0000000..8ccdc73
--- /dev/null
+++ b/src/components/controllers/ControllersRoute.tsx
@@ -0,0 +1,1211 @@
+import { useEffect, useMemo, useRef, useState, Fragment } from 'react';
+import {
+    Monitor,
+    Pencil,
+    Plus,
+    RefreshCw,
+    Save,
+    Search,
+    Server,
+    ShieldCheck,
+    Trash2,
+    X,
+} from 'lucide-react';
+
+import { Card } from '@/components/ui/Card';
+import { Select } from '@/components/ui/Select';
+import { vpsApi } from '@/services/vpsApi';
+
+import type { ControllerClient } from '@/services/vpsApi';
+
+const scrollClass =
+    '[scrollbar-width:thin] [scrollbar-color:rgba(59,130,246,0.55)_transparent] [&::-webkit-scrollbar]:w-2 [&::-webkit-scrollbar-track]:bg-transparent [&::-webkit-scrollbar-thumb]:rounded-full [&::-webkit-scrollbar-thumb]:bg-blue-500/45 hover:[&::-webkit-scrollbar-thumb]:bg-blue-500/65';
+
+const controllerFilterOptions: {
+    value: 'all' | 'with' | 'without';
+    label: string;
+}[] = [
+        { value: 'all', label: 'Todos' },
+        { value: 'with', label: 'Com controladores' },
+        { value: 'without', label: 'Sem controladores' },
+    ];
+
+const pageSizeOptions: {
+    value: '10' | '25' | '50';
+    label: string;
+}[] = [
+        { value: '10', label: '10 por página' },
+        { value: '25', label: '25 por página' },
+        { value: '50', label: '50 por página' },
+    ];
+
+export function ControllersRoute() {
+    const [search, setSearch] = useState('');
+    const [clients, setClients] = useState<ControllerClient[]>([]);
+    const [selectedId, setSelectedId] = useState('');
+    const [loading, setLoading] = useState(false);
+    const [error, setError] = useState('');
+    const [page, setPage] = useState(1);
+    const [pageSize, setPageSize] = useState<'10' | '25' | '50'>('10');
+    const [controllerFilter, setControllerFilter] =
+        useState<'all' | 'with' | 'without'>('all');
+
+    const [editingClient, setEditingClient] =
+        useState<ControllerClient | null>(null);
+
+    async function loadClients() {
+        try {
+            setLoading(true);
+            setError('');
+
+            const response = await vpsApi.listControllerClients();
+
+            setClients(response.clients);
+            setSelectedId((current) => current || response.clients[0]?.id || '');
+        } catch (err) {
+            setError(String(err));
+            setClients([]);
+            setSelectedId('');
+        } finally {
+            setLoading(false);
+        }
+    }
+
+    useEffect(() => {
+        loadClients();
+    }, []);
+
+    const filteredClients = useMemo(() => {
+        return clients.filter((client) => {
+            const matchesSearch = client.name
+                .toLowerCase()
+                .includes(search.toLowerCase());
+
+            const matchesControllerFilter =
+                controllerFilter === 'all' ||
+                (controllerFilter === 'with' && client.controller_count > 0) ||
+                (controllerFilter === 'without' && client.controller_count === 0);
+
+            return matchesSearch && matchesControllerFilter;
+        });
+    }, [clients, search, controllerFilter]);
+
+    useEffect(() => {
+        setPage(1);
+    }, [search, controllerFilter, pageSize]);
+
+    const pageSizeNumber = Number(pageSize);
+
+    const totalPages = Math.max(
+        1,
+        Math.ceil(filteredClients.length / pageSizeNumber),
+    );
+
+    const pagedClients = useMemo(() => {
+        const start = (page - 1) * pageSizeNumber;
+        return filteredClients.slice(start, start + pageSizeNumber);
+    }, [filteredClients, page, pageSizeNumber]);
+
+    const selectedClient =
+        filteredClients.find((client) => client.id === selectedId) ??
+        filteredClients[0];
+
+    return (
+        <div className="flex h-full min-h-0 flex-col overflow-hidden">
+            <div className="mb-4 flex shrink-0 items-start justify-between gap-4 rounded-3xl border border-white/10 bg-white/[0.025] px-5 py-4">
+                <div className="min-w-0">
+                    <h1 className="truncate text-3xl font-black tracking-tight text-white">
+                        Controladores
+                    </h1>
+
+                    <p className="mt-1 text-sm text-slate-400">
+                        Gestão de clientes, controladores, ficheiros VPS e regras do router.
+                    </p>
+                </div>
+
+                <button
+                    type="button"
+                    onClick={loadClients}
+                    disabled={loading}
+                    className="inline-flex shrink-0 items-center gap-2 rounded-2xl border border-blue-500/20 bg-blue-500/15 px-4 py-3 text-sm font-bold text-blue-100 transition hover:bg-blue-500/20 disabled:cursor-not-allowed disabled:opacity-50"
+                >
+                    <RefreshCw
+                        size={17}
+                        className={loading ? 'animate-spin' : ''}
+                    />
+
+                    {loading ? 'A atualizar...' : 'Atualizar'}
+                </button>
+            </div>
+
+            {error && (
+                <div className="mb-4 shrink-0 rounded-2xl border border-red-500/20 bg-red-500/10 p-4 text-sm text-red-300">
+                    Erro ao carregar clientes: {error}
+                </div>
+            )}
+
+            <div className="grid min-h-0 flex-1 gap-4 overflow-hidden xl:grid-cols-12">
+                <Card className="flex min-h-0 flex-col overflow-hidden xl:col-span-5">
+                    <div className="mb-4 flex shrink-0 items-center justify-between gap-3">
+                        <div>
+                            <h3 className="font-bold text-white">
+                                Clientes
+                            </h3>
+
+                            <p className="text-xs text-slate-500">
+                                Ficheiros em /var/litoral_regas_app/maquinas
+                            </p>
+                        </div>
+
+                        <div className="rounded-2xl bg-white/[0.03] px-3 py-2 text-xs font-bold text-slate-300">
+                            {filteredClients.length} / {clients.length} clientes
+                        </div>
+                    </div>
+
+                    <div className="mb-4 shrink-0">
+                        <label className="mb-2 block text-xs font-medium uppercase tracking-[0.16em] text-slate-500">
+                            Pesquisa
+                        </label>
+
+                        <div className="flex items-center gap-2 rounded-xl border border-white/10 bg-slate-950 px-3 py-3">
+                            <Search size={17} className="text-slate-500" />
+
+                            <input
+                                value={search}
+                                onChange={(event) =>
+                                    setSearch(event.target.value)
+                                }
+                                placeholder="Pesquisar cliente..."
+                                className="w-full bg-transparent text-sm text-white outline-none placeholder:text-slate-600"
+                            />
+                        </div>
+                    </div>
+
+                    <div className="mb-4 grid shrink-0 grid-cols-2 gap-3">
+                        <div>
+                            <label className="mb-2 block text-xs font-medium uppercase tracking-[0.16em] text-slate-500">
+                                Estado
+                            </label>
+
+                            <Select
+                                value={controllerFilter}
+                                options={controllerFilterOptions}
+                                onChange={setControllerFilter}
+                            />
+                        </div>
+
+                        <div>
+                            <label className="mb-2 block text-xs font-medium uppercase tracking-[0.16em] text-slate-500">
+                                Paginação
+                            </label>
+
+                            <Select
+                                value={pageSize}
+                                options={pageSizeOptions}
+                                onChange={setPageSize}
+                            />
+                        </div>
+                    </div>
+
+                    <div
+                        className={`min-h-0 flex-1 space-y-2 overflow-y-auto pr-2 ${scrollClass}`}
+                    >
+                        {loading && clients.length === 0 && (
+                            <div className="rounded-2xl border border-white/10 bg-white/[0.025] p-4 text-sm text-slate-400">
+                                A carregar clientes da VPS...
+                            </div>
+                        )}
+
+                        {!loading && filteredClients.length === 0 && (
+                            <div className="rounded-2xl border border-white/10 bg-white/[0.025] p-4 text-sm text-slate-400">
+                                Nenhum cliente encontrado.
+                            </div>
+                        )}
+
+                        {pagedClients.map((client) => {
+                            const active = selectedClient?.id === client.id;
+
+                            return (
+                                <button
+                                    key={client.id}
+                                    type="button"
+                                    onClick={() => setSelectedId(client.id)}
+                                    className={`w-full rounded-2xl border p-4 text-left transition ${active
+                                        ? 'border-blue-500/25 bg-blue-500/10'
+                                        : 'border-white/10 bg-white/[0.025] hover:bg-white/[0.045]'
+                                        }`}
+                                >
+                                    <div className="flex items-start justify-between gap-3">
+                                        <div className="min-w-0">
+                                            <p className="truncate font-bold text-white">
+                                                {client.name}
+                                            </p>
+
+                                            <p className="mt-1 truncate font-mono text-xs text-slate-500">
+                                                {client.file}
+                                            </p>
+                                        </div>
+
+                                        <span
+                                            className={`rounded-xl px-2.5 py-1 text-xs font-bold ${client.controller_count > 0
+                                                ? 'bg-blue-500/10 text-blue-200'
+                                                : 'bg-white/[0.04] text-slate-400'
+                                                }`}
+                                        >
+                                            {client.controller_count}
+                                        </span>
+                                    </div>
+
+                                    <div className="mt-3 flex items-center gap-2 text-xs text-slate-500">
+                                        <ShieldCheck
+                                            size={14}
+                                            className={
+                                                client.controller_count > 0
+                                                    ? 'text-blue-300'
+                                                    : 'text-slate-600'
+                                            }
+                                        />
+
+                                        <span>
+                                            {client.controller_count > 0
+                                                ? 'Com controladores'
+                                                : 'Sem controladores'}
+                                        </span>
+                                    </div>
+                                </button>
+                            );
+                        })}
+                    </div>
+
+                    <div className="mt-4 flex shrink-0 items-center justify-between gap-3 border-t border-white/10 pt-4 text-xs text-slate-400">
+                        <span>
+                            Página {page} de {totalPages} ·{' '}
+                            {filteredClients.length} resultados
+                        </span>
+
+                        <div className="flex gap-2">
+                            <button
+                                type="button"
+                                disabled={page <= 1}
+                                onClick={() =>
+                                    setPage((current) =>
+                                        Math.max(1, current - 1),
+                                    )
+                                }
+                                className="rounded-xl border border-white/10 px-3 py-2 font-bold text-slate-300 transition hover:bg-white/[0.04] disabled:cursor-not-allowed disabled:opacity-40"
+                            >
+                                Anterior
+                            </button>
+
+                            <button
+                                type="button"
+                                disabled={page >= totalPages}
+                                onClick={() =>
+                                    setPage((current) =>
+                                        Math.min(totalPages, current + 1),
+                                    )
+                                }
+                                className="rounded-xl border border-white/10 px-3 py-2 font-bold text-slate-300 transition hover:bg-white/[0.04] disabled:cursor-not-allowed disabled:opacity-40"
+                            >
+                                Seguinte
+                            </button>
+                        </div>
+                    </div>
+                </Card>
+
+                <Card className="min-h-0 overflow-hidden xl:col-span-7">
+                    {selectedClient ? (
+                        <div className="flex h-full flex-col overflow-y-auto">
+                            <div className="mb-5 flex items-start justify-between gap-4">
+                                <div>
+                                    <p className="text-xs font-bold uppercase tracking-[0.18em] text-blue-300/70">
+                                        Cliente selecionado
+                                    </p>
+
+                                    <h3 className="mt-2 text-2xl font-black text-white">
+                                        {selectedClient.name}
+                                    </h3>
+
+                                    <p className="mt-2 break-all font-mono text-xs text-slate-500">
+                                        {selectedClient.path}
+                                    </p>
+
+                                    <p className="mt-2 text-xs text-slate-500">
+                                        Última alteração:{' '}
+                                        {selectedClient.modified_at ?? '—'}
+                                    </p>
+                                </div>
+
+                                <button
+                                    type="button"
+                                    onClick={() =>
+                                        setEditingClient(selectedClient)
+                                    }
+                                    className="inline-flex items-center gap-2 rounded-2xl bg-blue-500 px-4 py-3 text-sm font-black text-white transition hover:bg-blue-400"
+                                >
+                                    <Pencil size={17} />
+                                    Editar Cliente
+                                </button>
+                            </div>
+
+                            <div className="grid gap-3 md:grid-cols-2">
+                                <MiniStat
+                                    icon={<Monitor size={18} />}
+                                    label="Controladores"
+                                    value={String(
+                                        selectedClient.controller_count,
+                                    )}
+                                />
+
+                                <MiniStat
+                                    icon={<Server size={18} />}
+                                    label="Ficheiro VPS"
+                                    value={selectedClient.file}
+                                />
+                            </div>
+
+                            <div className="mt-5 rounded-2xl border border-white/10 bg-white/[0.025] p-4">
+                                <h4 className="font-bold text-white">
+                                    Próximas ações
+                                </h4>
+
+                                <div className="mt-4 space-y-3 text-sm text-slate-400">
+                                    <p>• Abrir modal de edição do cliente.</p>
+                                    <p>
+                                        • Listar controladores do ficheiro .txt.
+                                    </p>
+                                    <p>
+                                        • Detetar router associado pelo IP
+                                        WireGuard.
+                                    </p>
+                                    <p>
+                                        • Adicionar, atualizar ou remover DNAT no
+                                        router.
+                                    </p>
+                                    <p>
+                                        • Atualizar entrada correspondente no
+                                        ficheiro VPS.
+                                    </p>
+                                </div>
+                            </div>
+                        </div>
+                    ) : (
+                        <div className="flex h-full items-center justify-center text-slate-500">
+                            Nenhum cliente selecionado.
+                        </div>
+                    )}
+                </Card>
+            </div>
+
+            {editingClient && (
+                <EditClientModal
+                    client={editingClient}
+                    onClose={() => setEditingClient(null)}
+                />
+            )}
+        </div>
+    );
+}
+
+function MiniStat({
+    icon,
+    label,
+    value,
+}: {
+    icon: React.ReactNode;
+    label: string;
+    value: string;
+}) {
+    return (
+        <div className="rounded-2xl border border-white/10 bg-white/[0.03] p-4">
+            <div className="mb-3 w-fit rounded-xl bg-blue-500/10 p-2 text-blue-300">
+                {icon}
+            </div>
+
+            <p className="text-xs text-slate-500">
+                {label}
+            </p>
+
+            <p className="mt-1 truncate font-black text-white">
+                {value}
+            </p>
+        </div>
+    );
+}
+
+type EditableController = {
+    id: string;
+    name: string;
+    routerVpnIp: string;
+    externalPort: string;
+    password: string;
+};
+
+function EditClientModal({
+    client,
+    onClose,
+}: {
+    client: ControllerClient;
+    onClose: () => void;
+}) {
+    const [clientPassword, setClientPassword] = useState('');
+    const [controllers, setControllers] = useState<EditableController[]>([]);
+    const [loadingClientFile, setLoadingClientFile] = useState(true);
+    const [clientFileError, setClientFileError] = useState('');
+
+    useEffect(() => {
+        let cancelled = false;
+
+        async function loadClientFile() {
+            try {
+                setLoadingClientFile(true);
+                setClientFileError('');
+
+                const response = await vpsApi.readControllerClient(client.id);
+
+                if (cancelled) return;
+
+                const parsed = parseClientTxt(response.content);
+
+                setClientPassword(parsed.password);
+                setControllers(parsed.controllers);
+            } catch (err) {
+                if (cancelled) return;
+
+                setClientFileError(String(err));
+                setClientPassword('');
+                setControllers([]);
+            } finally {
+                if (!cancelled) {
+                    setLoadingClientFile(false);
+                }
+            }
+        }
+
+        loadClientFile();
+
+        return () => {
+            cancelled = true;
+        };
+    }, [client.id]);
+
+    const controllerErrors = useMemo(
+        () => controllers.map(validateController),
+        [controllers],
+    );
+
+    const clientPasswordError = useMemo(() => {
+        if (loadingClientFile) return '';
+        if (!clientPassword.trim()) return 'A palavra-passe é obrigatória.';
+
+        if (hasTxtSeparator(clientPassword)) {
+            return 'A palavra-passe não pode conter "xxx" ou quebras de linha.';
+        }
+
+        return '';
+    }, [clientPassword, loadingClientFile]);
+
+    const formIsValid =
+        !loadingClientFile &&
+        !clientFileError &&
+        !clientPasswordError &&
+        controllers.length > 0 &&
+        controllerErrors.every((errors) => !hasErrors(errors));
+
+    const txtPreview = useMemo(() => {
+        const lines = [
+            clientPassword,
+            ...controllers.map(
+                (controller) =>
+                    `${controller.name}xxx${controller.routerVpnIp}xxx${controller.externalPort}xxx${controller.password}`,
+            ),
+        ];
+
+        return `${lines.join('\n')}\n`;
+    }, [clientPassword, controllers]);
+
+    function updateController(
+        id: string,
+        patch: Partial<EditableController>,
+    ) {
+        setControllers((current) =>
+            current.map((controller) =>
+                controller.id === id
+                    ? { ...controller, ...patch }
+                    : controller,
+            ),
+        );
+    }
+
+    function addController() {
+        setControllers((current) => [
+            ...current,
+            {
+                id: crypto.randomUUID(),
+                name: `Controlador${current.length + 1}`,
+                routerVpnIp: '',
+                externalPort: getNextAvailablePort(current),
+                password: '111111',
+            },
+        ]);
+    }
+
+    function removeController(id: string) {
+        setControllers((current) =>
+            current.filter((controller) => controller.id !== id),
+        );
+    }
+
+    return (
+        <div className="fixed inset-0 z-50 flex items-center justify-center bg-black/70 p-6 backdrop-blur-sm">
+            <div className="flex max-h-[90vh] w-full max-w-6xl flex-col overflow-hidden rounded-3xl border border-white/10 bg-[#050b1a] shadow-2xl">
+                <div className="flex items-start justify-between gap-4 border-b border-white/10 px-6 py-5">
+                    <div>
+                        <p className="text-xs font-bold uppercase tracking-[0.18em] text-blue-300/70">
+                            Editar Cliente
+                        </p>
+
+                        <h2 className="mt-2 text-2xl font-black text-white">
+                            {client.name}
+                        </h2>
+
+                        <p className="mt-1 break-all font-mono text-xs text-slate-500">
+                            {client.path}
+                        </p>
+                    </div>
+
+                    <button
+                        type="button"
+                        onClick={onClose}
+                        className="rounded-2xl border border-white/10 bg-white/[0.03] p-3 text-slate-400 transition hover:bg-white/[0.06] hover:text-white"
+                    >
+                        <X size={18} />
+                    </button>
+                </div>
+
+                {loadingClientFile ? (
+                    <div className="flex min-h-[420px] items-center justify-center text-sm text-slate-400">
+                        A carregar ficheiro do cliente...
+                    </div>
+                ) : clientFileError ? (
+                    <div className="m-6 rounded-2xl border border-red-500/20 bg-red-500/10 p-4 text-sm text-red-300">
+                        Erro ao carregar ficheiro do cliente: {clientFileError}
+                    </div>
+                ) : (
+                    <div className="grid min-h-0 flex-1 gap-4 overflow-hidden p-6 xl:grid-cols-12">
+                        <div className="space-y-4 xl:col-span-7">
+                            <div className="rounded-3xl border border-white/10 bg-white/[0.025] p-5">
+                                <h3 className="font-bold text-white">
+                                    Dados do Cliente
+                                </h3>
+
+                                <div className="mt-4">
+                                    <Field
+                                        label="Palavra-passe / primeira linha do ficheiro"
+                                        value={clientPassword}
+                                        error={clientPasswordError}
+                                        onChange={setClientPassword}
+                                    />
+                                </div>
+                            </div>
+
+                            <div className="rounded-3xl border border-white/10 bg-white/[0.025] p-5">
+                                <div className="mb-4 flex items-center justify-between gap-3">
+                                    <div>
+                                        <h3 className="font-bold text-white">
+                                            Controladores
+                                        </h3>
+
+                                        <p className="text-xs text-slate-500">
+                                            Entradas carregadas do ficheiro real do cliente.
+                                        </p>
+                                    </div>
+
+                                    <button
+                                        type="button"
+                                        onClick={addController}
+                                        className="inline-flex items-center gap-2 rounded-2xl border border-blue-500/20 bg-blue-500/15 px-4 py-3 text-sm font-bold text-blue-100 transition hover:bg-blue-500/20"
+                                    >
+                                        <Plus size={16} />
+                                        Adicionar
+                                    </button>
+                                </div>
+
+                                <div className={`max-h-[360px] space-y-3 overflow-y-auto pr-2 ${scrollClass}`}>
+                                    {controllers.map((controller, index) => (
+                                        <div
+                                            key={controller.id}
+                                            className="rounded-2xl border border-white/10 bg-black/15 p-4"
+                                        >
+                                            <div className="mb-3 flex items-center justify-between">
+                                                <p className="text-sm font-bold text-white">
+                                                    Controlador #{index + 1}
+                                                </p>
+
+                                                <button
+                                                    type="button"
+                                                    onClick={() =>
+                                                        removeController(controller.id)
+                                                    }
+                                                    className="rounded-xl p-2 text-slate-500 transition hover:bg-red-500/10 hover:text-red-300"
+                                                >
+                                                    <Trash2 size={16} />
+                                                </button>
+                                            </div>
+
+                                            <div className="grid gap-3 md:grid-cols-2">
+                                                <Field
+                                                    label="Nome"
+                                                    value={controller.name}
+                                                    error={controllerErrors[index]?.name}
+                                                    onChange={(value) =>
+                                                        updateController(controller.id, {
+                                                            name: value.replace(
+                                                                /[^A-Za-z0-9_-]/g,
+                                                                '',
+                                                            ),
+                                                        })
+                                                    }
+                                                />
+
+                                                <SmartRouterField
+                                                    label="Router / Host"
+                                                    value={controller.routerVpnIp}
+                                                    error={controllerErrors[index]?.routerVpnIp}
+                                                    onChange={(value) =>
+                                                        updateController(controller.id, {
+                                                            routerVpnIp: value,
+                                                        })
+                                                    }
+                                                />
+
+                                                <Field
+                                                    label="Porta externa"
+                                                    type="number"
+                                                    min={5900}
+                                                    max={5999}
+                                                    step={1}
+                                                    value={controller.externalPort}
+                                                    error={
+                                                        controllerErrors[index]?.externalPort
+                                                    }
+                                                    inputMode="numeric"
+                                                    onChange={(value) =>
+                                                        updateController(controller.id, {
+                                                            externalPort: value,
+                                                        })
+                                                    }
+                                                />
+
+                                                <Field
+                                                    label="PIN / Password"
+                                                    value={controller.password}
+                                                    error={controllerErrors[index]?.password}
+                                                    inputMode="numeric"
+                                                    maxLength={6}
+                                                    onChange={(value) =>
+                                                        updateController(controller.id, {
+                                                            password: value
+                                                                .replace(/\D/g, '')
+                                                                .slice(0, 6),
+                                                        })
+                                                    }
+                                                />
+                                            </div>
+                                        </div>
+                                    ))}
+                                </div>
+                            </div>
+                        </div>
+
+                        <div className="xl:col-span-5">
+                            <div className="sticky top-0 rounded-3xl border border-white/10 bg-white/[0.025] p-5">
+                                <div className="mb-4 flex items-center justify-between gap-3">
+                                    <div>
+                                        <h3 className="font-bold text-white">
+                                            Preview .txt
+                                        </h3>
+
+                                        <p className="text-xs text-slate-500">
+                                            Conteúdo exato a guardar no ficheiro.
+                                        </p>
+                                    </div>
+
+                                    <span className="rounded-2xl bg-white/[0.04] px-3 py-2 text-xs font-bold text-slate-300">
+                                        {controllers.length} entradas
+                                    </span>
+                                </div>
+
+                                <pre className={`max-h-[520px] overflow-auto whitespace-pre-wrap rounded-2xl border border-white/10 bg-black/30 p-4 font-mono text-xs leading-6 text-slate-300 ${scrollClass}`}>
+                                    {txtPreview}
+                                </pre>
+                            </div>
+                        </div>
+                    </div>
+                )}
+
+                <div className="flex items-center justify-between gap-3 border-t border-white/10 px-6 py-4">
+                    <p className="text-xs text-slate-500">
+                        Dados carregados diretamente do ficheiro do cliente.
+                    </p>
+
+                    <div className="flex gap-3">
+                        <button
+                            type="button"
+                            onClick={onClose}
+                            className="rounded-2xl border border-white/10 px-4 py-3 text-sm font-bold text-slate-300 transition hover:bg-white/[0.04]"
+                        >
+                            Cancelar
+                        </button>
+
+                        <button
+                            type="button"
+                            disabled={!formIsValid}
+                            className="inline-flex items-center gap-2 rounded-2xl bg-blue-500 px-5 py-3 text-sm font-black text-white transition hover:bg-blue-400 disabled:cursor-not-allowed disabled:bg-slate-700 disabled:text-slate-400"
+                        >
+                            <Save size={16} />
+                            Guardar alterações
+                        </button>
+                    </div>
+                </div>
+            </div>
+        </div>
+    );
+}
+
+function parseClientTxt(content: string): {
+    password: string;
+    controllers: EditableController[];
+} {
+    const lines = content
+        .replace(/\r\n/g, '\n')
+        .replace(/\r/g, '\n')
+        .split('\n')
+        .filter((line) => line.length > 0);
+
+    const password = lines[0] ?? '';
+
+    const controllers = lines.slice(1).map((line, index) => {
+        const [name = '', routerVpnIp = '', externalPort = '', password = ''] =
+            line.split('xxx');
+
+        return {
+            id: crypto.randomUUID(),
+            name,
+            routerVpnIp,
+            externalPort,
+            password,
+        };
+    });
+
+    return {
+        password,
+        controllers,
+    };
+}
+
+function Field({
+    label,
+    value,
+    onChange,
+    error,
+    inputMode,
+    maxLength,
+    type = 'text',
+    min,
+    max,
+    step,
+    hideLabel = false,
+    placeholder,
+    autoFocus = false
+}: {
+    label: string;
+    value: string;
+    onChange: (value: string) => void;
+    error?: string;
+    inputMode?: React.HTMLAttributes<HTMLInputElement>['inputMode'];
+    maxLength?: number;
+    type?: React.HTMLInputTypeAttribute;
+    min?: number;
+    max?: number;
+    step?: number;
+    hideLabel?: boolean;
+    placeholder?: string;
+    autoFocus?: boolean;
+}) {
+    return (
+        <div>
+            {!hideLabel && (
+                <label className="mb-2 block text-xs font-medium uppercase tracking-[0.16em] text-slate-500">
+                    {label}
+                </label>
+            )}
+
+            <div className="relative">
+                <input
+                    type={type}
+                    value={value}
+                    autoFocus={autoFocus}
+                    min={min}
+                    max={max}
+                    placeholder={placeholder}
+                    step={step}
+                    inputMode={inputMode}
+                    maxLength={maxLength}
+                    onChange={(event) => onChange(event.target.value)}
+                    className={`w-full rounded-xl border bg-slate-950 px-3 py-3 pr-12 font-mono text-sm text-white outline-none transition placeholder:text-slate-600 [appearance:textfield] [&::-webkit-outer-spin-button]:appearance-none [&::-webkit-inner-spin-button]:appearance-none ${error
+                        ? 'border-red-500/60 focus:border-red-400'
+                        : 'border-white/10 focus:border-blue-500/40'
+                        }`}
+                />
+
+                {type === 'number' && (
+                    <div className="absolute right-2 top-1/2 flex -translate-y-1/2 flex-col gap-1">
+                        <button
+                            type="button"
+                            onClick={() => {
+                                const current = Number(value || 0);
+                                const next = current + Number(step || 1);
+
+                                if (typeof max === 'number' && next > max) return;
+
+                                onChange(String(next));
+                            }}
+                            className="flex h-4 w-4 items-center justify-center rounded bg-white/[0.06] text-[10px] text-slate-300 transition hover:bg-blue-500/20 hover:text-white"
+                        >
+                            +
+                        </button>
+
+                        <button
+                            type="button"
+                            onClick={() => {
+                                const current = Number(value || 0);
+                                const next = current - Number(step || 1);
+
+                                const floor = typeof min === 'number' ? min : 5900;
+
+                                onChange(String(Math.max(floor, next)));
+                            }}
+                            className="flex h-4 w-4 items-center justify-center rounded bg-white/[0.06] text-[10px] text-slate-300 transition hover:bg-blue-500/20 hover:text-white"
+                        >
+                            −
+                        </button>
+                    </div>
+                )}
+            </div>
+
+            {error && (
+                <p className="mt-2 text-xs font-medium text-red-300">
+                    {error}
+                </p>
+            )}
+        </div>
+    );
+}
+
+function IpField({
+    label,
+    value,
+    onChange,
+    error,
+    hideLabel = false,
+    autoFocusFirstOctet = false,
+    autoFocusOctetIndex = 0,
+}: {
+    label: string;
+    value: string;
+    onChange: (value: string) => void;
+    error?: string;
+    hideLabel?: boolean;
+    autoFocusFirstOctet?: boolean;
+    autoFocusOctetIndex?: number;
+}) {
+    const inputRefs = useRef<Array<HTMLInputElement | null>>([]);
+
+    useEffect(() => {
+        if (!autoFocusFirstOctet) return;
+
+        requestAnimationFrame(() => {
+            const input = inputRefs.current[autoFocusOctetIndex];
+
+            input?.focus();
+            input?.setSelectionRange(input.value.length, input.value.length);
+        });
+    }, [autoFocusFirstOctet, autoFocusOctetIndex]);
+
+    const parts = value.split('.');
+    const octets = Array.from({ length: 4 }, (_, index) => parts[index] ?? '');
+
+    function updateOctet(index: number, rawValue: string) {
+        const nextValue = rawValue.replace(/\D/g, '').slice(0, 3);
+
+        if (nextValue && Number(nextValue) > 255) return;
+
+        const nextOctets = [...octets];
+        nextOctets[index] = nextValue;
+
+        onChange(nextOctets.join('.'));
+    }
+
+    function handleKeyDown(
+        index: number,
+        event: React.KeyboardEvent<HTMLInputElement>,
+    ) {
+        if (event.key === '.') {
+            event.preventDefault();
+
+            inputRefs.current[index + 1]?.focus();
+
+            return;
+        }
+
+        if (event.key !== 'Backspace') return;
+
+        const current = octets[index];
+
+        if (current.length > 0) {
+            const nextOctets = [...octets];
+            nextOctets[index] = current.slice(0, -1);
+
+            onChange(nextOctets.join('.'));
+            event.preventDefault();
+
+            return;
+        }
+
+        if (index > 0) {
+            event.preventDefault();
+            inputRefs.current[index - 1]?.focus();
+        }
+    }
+
+    return (
+        <div>
+            {!hideLabel && (
+                <label className="mb-2 block text-xs font-medium uppercase tracking-[0.16em] text-slate-500">
+                    {label}
+                </label>
+            )}
+
+            <div
+                className={`flex items-center rounded-xl border bg-slate-950 px-3 py-2 font-mono text-sm text-white transition ${error
+                    ? 'border-red-500/60 focus-within:border-red-400'
+                    : 'border-white/10 focus-within:border-blue-500/40'
+                    }`}
+            >
+                {octets.map((octet, index) => (
+                    <Fragment key={index}>
+                        <input
+                            ref={(element) => {
+                                inputRefs.current[index] = element;
+                            }}
+                            value={octet}
+                            inputMode="numeric"
+                            maxLength={3}
+                            onChange={(event) =>
+                                updateOctet(index, event.target.value)
+                            }
+                            onKeyDown={(event) =>
+                                handleKeyDown(index, event)
+                            }
+                            className="w-full min-w-0 bg-transparent px-1 py-1 text-center outline-none"
+                        />
+
+                        {index < 3 && (
+                            <span className="select-none px-1 text-slate-500">
+                                .
+                            </span>
+                        )}
+                    </Fragment>
+                ))}
+            </div>
+
+            {error && (
+                <p className="mt-2 text-xs font-medium text-red-300">
+                    {error}
+                </p>
+            )}
+        </div>
+    );
+}
+
+type FieldErrors = Partial<Record<keyof EditableController, string>>;
+
+const IPV4_REGEX =
+    /^(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)(\.(25[0-5]|2[0-4]\d|1\d\d|[1-9]?\d)){3}$/;
+
+const HOSTNAME_REGEX =
+    /^(?=.{1,253}$)([a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?\.)+[a-zA-Z]{2,}$/;
+
+function isValidRouterHost(value: string) {
+    const trimmed = value.trim();
+
+    return IPV4_REGEX.test(trimmed) || HOSTNAME_REGEX.test(trimmed);
+}
+
+const INVALID_CONTROLLER_NAME_REGEX = /(xxx|\r|\n)/i;
+
+function hasTxtSeparator(value: string) {
+    return value.includes('xxx') || value.includes('\n') || value.includes('\r');
+}
+
+function validatePort(value: string) {
+    const port = Number(value);
+
+    if (!value.trim()) {
+        return 'A porta externa é obrigatória.';
+    }
+
+    if (!/^\d+$/.test(value)) {
+        return 'A porta deve conter apenas números.';
+    }
+
+    if (port < 5900 || port > 5999) {
+        return 'A porta deve estar entre 5900 e 5999.';
+    }
+
+    return '';
+}
+
+function getNextAvailablePort(controllers: EditableController[]) {
+    const usedPorts = new Set(
+        controllers
+            .map((controller) => Number(controller.externalPort))
+            .filter((port) => Number.isInteger(port) && port >= 5900),
+    );
+
+    let port = 5900;
+
+    while (usedPorts.has(port)) {
+        port += 1;
+    }
+
+    return String(port);
+}
+
+function validateController(controller: EditableController): FieldErrors {
+    const errors: FieldErrors = {};
+
+    if (!controller.name.trim()) {
+        errors.name = 'O nome é obrigatório.';
+    } else if (INVALID_CONTROLLER_NAME_REGEX.test(controller.name)) {
+        errors.name =
+            'O nome não pode conter "xxx" ou quebras de linha.';
+    }
+
+    if (!controller.routerVpnIp.trim()) {
+        errors.routerVpnIp = 'O router/host é obrigatório.';
+    } else if (!isValidRouterHost(controller.routerVpnIp)) {
+        errors.routerVpnIp = 'Introduz um IPv4 ou hostname válido.';
+    }
+
+    const portError = validatePort(controller.externalPort);
+    if (portError) errors.externalPort = portError;
+
+    if (!/^\d{6}$/.test(controller.password)) {
+        errors.password = 'O PIN/password deve ter exatamente 6 dígitos.';
+    }
+
+    return errors;
+}
+
+function hasErrors(errors: FieldErrors) {
+    return Object.values(errors).some(Boolean);
+}
+
+type RouterFieldMode = 'host' | 'ip';
+
+function SmartRouterField({
+    label,
+    value,
+    onChange,
+    error,
+}: {
+    label: string;
+    value: string;
+    onChange: (value: string) => void;
+    error?: string;
+}) {
+    const [mode, setMode] = useState<RouterFieldMode>(() =>
+        IPV4_REGEX.test(value.trim()) ? 'ip' : 'host',
+    );
+
+    const [focusOctetIndex, setFocusOctetIndex] = useState(0);
+    const [isFocused, setIsFocused] = useState(false);
+
+    useEffect(() => {
+        if (!value.trim()) {
+            setMode('host');
+            setFocusOctetIndex(0);
+        }
+    }, [value]);
+
+    function handleHostChange(nextValue: string) {
+        const shouldSwitchToIp =
+            /^[\d.]+$/.test(nextValue) && /\d+\.$/.test(nextValue);
+
+        if (shouldSwitchToIp) {
+            setFocusOctetIndex(
+                Math.min(nextValue.split('.').length - 1, 3),
+            );
+
+            setMode('ip');
+        }
+
+        onChange(nextValue);
+    }
+
+    function handleIpChange(nextValue: string) {
+        if (!nextValue.replace(/\./g, '').trim()) {
+            onChange('');
+            return;
+        }
+
+        onChange(nextValue);
+    }
+    return (
+    <div
+        onFocus={() => setIsFocused(true)}
+        onBlur={() => {
+            setIsFocused(false);
+
+            if (!value.trim()) {
+                setMode('host');
+                setFocusOctetIndex(0);
+            }
+        }}
+    >
+        <div className="mb-2 flex items-center justify-between gap-3">
+                <label className="block text-xs font-medium uppercase tracking-[0.16em] text-slate-500">
+                    {label}
+                </label>
+
+                <span className="rounded-xl border border-white/10 bg-slate-950 px-2.5 py-1 text-[10px] font-black uppercase tracking-[0.12em] text-blue-200">
+                    {mode === 'ip' ? 'Auto · IPv4' : 'Auto · Host'}
+                </span>
+            </div>
+
+            {mode === 'ip' ? (
+                <IpField
+                    label=""
+                    value={value}
+                    error={error}
+                    onChange={handleIpChange}
+                    hideLabel
+                    autoFocusFirstOctet
+                    autoFocusOctetIndex={focusOctetIndex}
+                />
+            ) : (
+                <Field
+                    label=""
+                    value={value}
+                    error={error}
+                    onChange={handleHostChange}
+                    placeholder="198.19.0.167 ou adoraflor.nsupdate.info"
+                    hideLabel
+                    autoFocus
+                />
+            )}
+        </div>
+    );
+}
\ No newline at end of file
diff --git a/src/components/layout/Sidebar.tsx b/src/components/layout/Sidebar.tsx
index 785a366..d3a885e 100644
--- a/src/components/layout/Sidebar.tsx
+++ b/src/components/layout/Sidebar.tsx
@@ -5,12 +5,14 @@ import {
   RadioTower,
   Settings,
   Wrench,
+  Router
 } from 'lucide-react';
 
 import logoIcon from '@/assets/logo-icon.png';
 
 const items = [
   ['Painel', Gauge],
+  ['Controladores', Router],
   ['Configuração UDP2RAW', RadioTower],
   ['Provisionamento', Wrench],
   ['Registos de Atividade', FileClock],
@@ -57,18 +59,16 @@ export function Sidebar({
               key={label}
               type="button"
               onClick={() => onSelect(label)}
-              className={`group flex w-full items-center gap-3 rounded-2xl px-4 py-3 text-left text-sm font-semibold transition-all duration-200 ${
-                isActive
+              className={`group flex w-full items-center gap-3 rounded-2xl px-4 py-3 text-left text-sm font-semibold transition-all duration-200 ${isActive
                   ? 'border border-blue-500/20 bg-blue-500/15 text-white shadow-[0_0_25px_rgba(59,130,246,0.12)]'
                   : 'border border-transparent text-slate-300 hover:border-white/5 hover:bg-white/[0.035] hover:text-white'
-              }`}
+                }`}
             >
               <div
-                className={`rounded-xl p-2 transition ${
-                  isActive
+                className={`rounded-xl p-2 transition ${isActive
                     ? 'bg-blue-500/10 text-blue-300'
                     : 'bg-white/[0.03] text-slate-400 group-hover:text-slate-200'
-                }`}
+                  }`}
               >
                 <Icon size={17} />
               </div>
diff --git a/src/services/apiClient.ts b/src/services/apiClient.ts
index fac75f2..03c82ec 100644
--- a/src/services/apiClient.ts
+++ b/src/services/apiClient.ts
@@ -1,9 +1,9 @@
 import type { AppSettings } from '@/types/api';
 
-const defaults: AppSettings = {
-  backendUrl: 'http://146.59.230.190:8080',
-  apiKey:
-    'b8184608fcab419da2ce9a220ee6017daaff637b627e43ebac31b6b7c3344349',
+const defaults: AppSettings = { // FOR DEBUG AND DEV PURPOSES ONLY ==========================>
+  backendUrl: 'http://localhost:8080',// FOR DEBUG AND DEV PURPOSES ONLY ==========================>
+  apiKey:// FOR DEBUG AND DEV PURPOSES ONLY ==========================>
+    'dev-api-key',// FOR DEBUG AND DEV PURPOSES ONLY ==========================>
 };
 
 const SETTINGS_KEY =
diff --git a/src/services/vpsApi.ts b/src/services/vpsApi.ts
index a53e98b..18e04bd 100644
--- a/src/services/vpsApi.ts
+++ b/src/services/vpsApi.ts
@@ -5,21 +5,32 @@ import type {
   VpsHealth,
 } from '@/types/api';
 
+export type ControllerClient = {
+  id: string;
+  name: string;
+  file: string;
+  path: string;
+  controller_count: number;
+  modified_at: string;
+};
+
+export type ControllerClientsResponse = {
+  clients: ControllerClient[];
+};
+
+export type ControllerClientFileResponse = {
+  content: string;
+};
+
 export const vpsApi = {
   health: () =>
-    apiRequest<VpsHealth>(
-      '/api/vps/health',
-    ),
+    apiRequest<VpsHealth>('/api/vps/health'),
 
   networkTraffic: () =>
-    apiRequest<NetworkTrafficResponse>(
-      '/api/vps/network-traffic',
-    ),
+    apiRequest<NetworkTrafficResponse>('/api/vps/network-traffic'),
 
   udp2rawTraffic: () =>
-    apiRequest<NetworkTrafficResponse>(
-      '/api/vps/udp2raw-traffic',
-    ),
+    apiRequest<NetworkTrafficResponse>('/api/vps/udp2raw-traffic'),
 
   rollbackLastBackup: () =>
     apiRequest<{ restored: boolean }>(
@@ -28,4 +39,16 @@ export const vpsApi = {
         method: 'POST',
       },
     ),
+
+  // ALL clients
+  listControllerClients: () =>
+    apiRequest<ControllerClientsResponse>(
+      '/api/vps/controllers/clients',
+    ),
+
+  // ONE client's .txt content
+  readControllerClient: (clientId: string) =>
+    apiRequest<ControllerClientFileResponse>(
+      `/api/vps/controllers/clients/${encodeURIComponent(clientId)}`,
+    ),
 };
\ No newline at end of file