conrolcenter: debug/rewrite of wireless panel

1 files changed, 302 insertions, 14 deletions

diff --git a/services/Network.qml b/services/Network.qml
index c8ab264..ea5c3e7 100644
--- a/services/Network.qml
+++ b/services/Network.qml
@@ -12,6 +12,8 @@ Singleton {
         Qt.callLater(() => {
             getEthernetDevices();
         });
+        // Load saved connections on startup
+        listConnectionsProc.running = true;
     }
 
     readonly property list<AccessPoint> networks: []
@@ -26,6 +28,34 @@ Singleton {
     property bool ethernetProcessRunning: false
     property var ethernetDeviceDetails: null
     property var wirelessDeviceDetails: null
+    property string connectionStatus: ""
+    property string connectionDebug: ""
+    
+    function clearConnectionStatus(): void {
+        connectionStatus = "";
+        // Don't clear debug - keep it for reference
+        // connectionDebug = "";
+    }
+    
+    function setConnectionStatus(status: string): void {
+        connectionStatus = status;
+    }
+    
+    function addDebugInfo(info: string): void {
+        const timestamp = new Date().toLocaleTimeString();
+        const newInfo = "[" + timestamp + "] " + info;
+        // CRITICAL: Always append - NEVER replace
+        // Get current value - NEVER allow it to be empty/cleared
+        let current = connectionDebug;
+        if (!current || current === undefined || current === null) {
+            current = "";
+        }
+        // ALWAYS append - never replace
+        // If current is empty, just use newInfo, otherwise append with newline
+        const updated = (current.length > 0) ? (current + "\n" + newInfo) : newInfo;
+        // CRITICAL: Only assign if we're appending, never replace
+        connectionDebug = updated;
+    }
 
     function enableWifi(enabled: bool): void {
         const cmd = enabled ? "on" : "off";
@@ -44,30 +74,118 @@ Singleton {
     property var pendingConnection: null
     signal connectionFailed(string ssid)
 
-    function connectToNetwork(ssid: string, password: string): void {
-        // First try to connect to an existing connection
-        // If that fails, create a new connection
+    function connectToNetwork(ssid: string, password: string, bssid: string, callback: var): void {
+        // When password is provided, use BSSID for more reliable connection
+        // When no password, use SSID (will use saved password if available)
+        const hasBssid = bssid !== undefined && bssid !== null && bssid.length > 0;
+        let cmd = [];
+        
+        // Set up pending connection tracking if callback provided
+        if (callback) {
+            root.pendingConnection = { ssid: ssid, bssid: hasBssid ? bssid : "", callback: callback };
+        }
+        
         if (password && password.length > 0) {
-            connectProc.exec(["nmcli", "device", "wifi", "connect", ssid, "password", password]);
+            // When password is provided, try BSSID first if available, otherwise use SSID
+            if (hasBssid) {
+                // Use BSSID when password is provided - ensure BSSID is uppercase
+                const bssidUpper = bssid.toUpperCase();
+                // Create connection profile with all required properties for BSSID + password
+                // First remove any existing connection with this name
+                cmd = ["nmcli", "connection", "add", 
+                       "type", "wifi", 
+                       "con-name", ssid,
+                       "ifname", "*",
+                       "ssid", ssid,
+                       "802-11-wireless.bssid", bssidUpper,
+                       "802-11-wireless-security.key-mgmt", "wpa-psk",
+                       "802-11-wireless-security.psk", password];
+                root.setConnectionStatus(qsTr("Connecting to %1 (BSSID: %2)...").arg(ssid).arg(bssidUpper));
+                root.addDebugInfo(qsTr("Using BSSID: %1 for SSID: %2").arg(bssidUpper).arg(ssid));
+                root.addDebugInfo(qsTr("Creating connection profile with password and key-mgmt"));
+            } else {
+                // Fallback to SSID if BSSID not available - use device wifi connect
+                cmd = ["nmcli", "device", "wifi", "connect", ssid, "password", password];
+                root.setConnectionStatus(qsTr("Connecting to %1...").arg(ssid));
+                root.addDebugInfo(qsTr("Using SSID only (no BSSID): %1").arg(ssid));
+            }
         } else {
             // Try to connect to existing connection first (will use saved password if available)
-            connectProc.exec(["nmcli", "device", "wifi", "connect", ssid]);
+            cmd = ["nmcli", "device", "wifi", "connect", ssid];
+            root.setConnectionStatus(qsTr("Connecting to %1 (using saved password)...").arg(ssid));
+            root.addDebugInfo(qsTr("Using saved password for: %1").arg(ssid));
+        }
+        
+        // Show the exact command being executed
+        const cmdStr = cmd.join(" ");
+        root.addDebugInfo(qsTr("=== COMMAND TO EXECUTE ==="));
+        root.addDebugInfo(qsTr("Command: %1").arg(cmdStr));
+        root.addDebugInfo(qsTr("Command array: [%1]").arg(cmd.map((arg, i) => `"${arg}"`).join(", ")));
+        root.addDebugInfo(qsTr("Command array length: %1").arg(cmd.length));
+        root.addDebugInfo(qsTr("==========================="));
+        
+        // Set command and start process
+        root.addDebugInfo(qsTr("Setting command property..."));
+        connectProc.command = cmd;
+        const setCmdStr = connectProc.command ? connectProc.command.join(" ") : "null";
+        root.addDebugInfo(qsTr("Command property set, value: %1").arg(setCmdStr));
+        root.addDebugInfo(qsTr("Command property verified: %1").arg(setCmdStr === cmdStr ? "Match" : "MISMATCH"));
+        
+        // If we're creating a connection profile, we need to activate it after creation
+        const isConnectionAdd = cmd.length > 0 && cmd[0] === "nmcli" && cmd[1] === "connection" && cmd[2] === "add";
+        
+        // Wait a moment before starting to ensure command is set
+        Qt.callLater(() => {
+            root.addDebugInfo(qsTr("=== STARTING PROCESS ==="));
+            root.addDebugInfo(qsTr("Current running state: %1").arg(connectProc.running));
+            root.addDebugInfo(qsTr("Command to run: %1").arg(connectProc.command ? connectProc.command.join(" ") : "NOT SET"));
+            root.addDebugInfo(qsTr("Is connection add command: %1").arg(isConnectionAdd));
+            connectProc.running = true;
+            root.addDebugInfo(qsTr("Process running set to: %1").arg(connectProc.running));
+            root.addDebugInfo(qsTr("========================"));
+            
+            // Check if process actually started after a short delay
+            Qt.callLater(() => {
+                root.addDebugInfo(qsTr("Process status check (100ms later):"));
+                root.addDebugInfo(qsTr("  Running: %1").arg(connectProc.running));
+                root.addDebugInfo(qsTr("  Command: %1").arg(connectProc.command ? connectProc.command.join(" ") : "null"));
+                if (!connectProc.running) {
+                    root.addDebugInfo(qsTr("WARNING: Process did not start!"));
+                    root.setConnectionStatus(qsTr("Error: Process failed to start"));
+                }
+            }, 100);
+        });
+        
+        // Start connection check timer if we have a callback
+        if (callback) {
+            root.addDebugInfo(qsTr("Starting connection check timer (4 second interval)"));
+            connectionCheckTimer.start();
+        } else {
+            root.addDebugInfo(qsTr("No callback provided - not starting connection check timer"));
         }
     }
 
-    function connectToNetworkWithPasswordCheck(ssid: string, isSecure: bool, callback: var): void {
+    function connectToNetworkWithPasswordCheck(ssid: string, isSecure: bool, callback: var, bssid: string): void {
+        root.addDebugInfo(qsTr("=== connectToNetworkWithPasswordCheck ==="));
+        root.addDebugInfo(qsTr("SSID: %1, isSecure: %2").arg(ssid).arg(isSecure));
+        
         // For secure networks, try connecting without password first
         // If connection succeeds (saved password exists), we're done
         // If it fails with password error, callback will be called to show password dialog
         if (isSecure) {
-            root.pendingConnection = { ssid: ssid, callback: callback };
+            const hasBssid = bssid !== undefined && bssid !== null && bssid.length > 0;
+            root.pendingConnection = { ssid: ssid, bssid: hasBssid ? bssid : "", callback: callback };
+            root.addDebugInfo(qsTr("Trying to connect without password (will use saved if available)"));
             // Try connecting without password - will use saved password if available
             connectProc.exec(["nmcli", "device", "wifi", "connect", ssid]);
             // Start timer to check if connection succeeded
+            root.addDebugInfo(qsTr("Starting connection check timer"));
             connectionCheckTimer.start();
         } else {
-            connectToNetwork(ssid, "");
+            root.addDebugInfo(qsTr("Network is not secure, connecting directly"));
+            connectToNetwork(ssid, "", bssid, null);
         }
+        root.addDebugInfo(qsTr("========================================="));
     }
 
     function disconnectFromNetwork(): void {
@@ -80,6 +198,50 @@ Singleton {
             disconnectProc.exec(["nmcli", "device", "disconnect", "wifi"]);
         }
     }
+    
+    function forgetNetwork(ssid: string): void {
+        // Delete the connection profile for this network
+        // This will remove the saved password and connection settings
+        if (ssid && ssid.length > 0) {
+            deleteConnectionProc.exec(["nmcli", "connection", "delete", ssid]);
+            // Also refresh network list after deletion
+            Qt.callLater(() => {
+                getNetworks.running = true;
+            }, 500);
+        }
+    }
+    
+    function hasConnectionProfile(ssid: string): bool {
+        // Check if a connection profile exists for this SSID
+        // This is synchronous check - returns true if connection exists
+        if (!ssid || ssid.length === 0) {
+            return false;
+        }
+        // Use nmcli to check if connection exists
+        // We'll use a Process to check, but for now return false
+        // The actual check will be done asynchronously
+        return false;
+    }
+    
+    property list<string> savedConnections: []
+    
+    Process {
+        id: listConnectionsProc
+        command: ["nmcli", "-t", "-f", "NAME", "connection", "show"]
+        onExited: {
+            if (exitCode === 0) {
+                // Parse connection names from output
+                const connections = stdout.text.trim().split("\n").filter(name => name.length > 0);
+                root.savedConnections = connections;
+            }
+        }
+        stdout: StdioCollector {
+            onStreamFinished: {
+                const connections = text.trim().split("\n").filter(name => name.length > 0);
+                root.savedConnections = connections;
+            }
+        }
+    }
 
     function getWifiStatus(): void {
         wifiStatusProc.running = true;
@@ -184,11 +346,17 @@ Singleton {
         id: connectionCheckTimer
         interval: 4000
         onTriggered: {
+            root.addDebugInfo(qsTr("=== CONNECTION CHECK TIMER (4s) ==="));
             if (root.pendingConnection) {
-                // Final check - if connection still hasn't succeeded, show password dialog
                 const connected = root.active && root.active.ssid === root.pendingConnection.ssid;
+                root.addDebugInfo(qsTr("Checking connection status..."));
+                root.addDebugInfo(qsTr("  Pending SSID: %1").arg(root.pendingConnection.ssid));
+                root.addDebugInfo(qsTr("  Active SSID: %1").arg(root.active ? root.active.ssid : "None"));
+                root.addDebugInfo(qsTr("  Connected: %1").arg(connected));
+                
                 if (!connected && root.pendingConnection.callback) {
                     // Connection didn't succeed after multiple checks, show password dialog
+                    root.addDebugInfo(qsTr("Connection failed - calling password dialog callback"));
                     const pending = root.pendingConnection;
                     root.pendingConnection = null;
                     immediateCheckTimer.stop();
@@ -196,11 +364,19 @@ Singleton {
                     pending.callback();
                 } else if (connected) {
                     // Connection succeeded, clear pending
+                    root.addDebugInfo(qsTr("Connection succeeded!"));
+                    root.setConnectionStatus(qsTr("Connected successfully!"));
                     root.pendingConnection = null;
                     immediateCheckTimer.stop();
                     immediateCheckTimer.checkCount = 0;
+                } else {
+                    root.addDebugInfo(qsTr("Still connecting..."));
+                    root.setConnectionStatus(qsTr("Still connecting..."));
                 }
+            } else {
+                root.addDebugInfo(qsTr("No pending connection"));
             }
+            root.addDebugInfo(qsTr("================================"));
         }
     }
 
@@ -210,23 +386,37 @@ Singleton {
         repeat: true
         triggeredOnStart: false
         property int checkCount: 0
+        
+        onRunningChanged: {
+            if (running) {
+                root.addDebugInfo(qsTr("Immediate check timer started (checks every 500ms)"));
+            }
+        }
+        
         onTriggered: {
             if (root.pendingConnection) {
                 checkCount++;
                 const connected = root.active && root.active.ssid === root.pendingConnection.ssid;
+                root.addDebugInfo(qsTr("Immediate check #%1: Connected=%2").arg(checkCount).arg(connected));
+                
                 if (connected) {
                     // Connection succeeded, stop timers and clear pending
+                    root.addDebugInfo(qsTr("Connection succeeded on check #%1!").arg(checkCount));
+                    root.setConnectionStatus(qsTr("Connected successfully!"));
                     connectionCheckTimer.stop();
                     immediateCheckTimer.stop();
                     immediateCheckTimer.checkCount = 0;
                     root.pendingConnection = null;
                 } else if (checkCount >= 6) {
+                    root.addDebugInfo(qsTr("Checked %1 times (3 seconds) - connection taking longer").arg(checkCount));
+                    root.setConnectionStatus(qsTr("Connection taking longer than expected..."));
                     // Checked 6 times (3 seconds total), connection likely failed
                     // Stop immediate check, let the main timer handle it
                     immediateCheckTimer.stop();
                     immediateCheckTimer.checkCount = 0;
                 }
             } else {
+                root.addDebugInfo(qsTr("Immediate check: No pending connection, stopping timer"));
                 immediateCheckTimer.stop();
                 immediateCheckTimer.checkCount = 0;
             }
@@ -236,22 +426,92 @@ Singleton {
     Process {
         id: connectProc
 
+        onRunningChanged: {
+            root.addDebugInfo(qsTr("Process running changed to: %1").arg(running));
+        }
+        
+        onStarted: {
+            root.addDebugInfo(qsTr("Process started successfully"));
+        }
+        
         onExited: {
+            root.addDebugInfo(qsTr("=== PROCESS EXITED ==="));
+            root.addDebugInfo(qsTr("Exit code: %1").arg(exitCode));
+            root.addDebugInfo(qsTr("(Exit code 0 = success, non-zero = error)"));
+            
+            // Check if this was a "connection add" command - if so, we need to activate it
+            const wasConnectionAdd = connectProc.command && connectProc.command.length > 0 
+                                   && connectProc.command[0] === "nmcli" 
+                                   && connectProc.command[1] === "connection" 
+                                   && connectProc.command[2] === "add";
+            
+            if (wasConnectionAdd && exitCode === 0 && root.pendingConnection) {
+                // Connection profile was created successfully, now activate it
+                const ssid = root.pendingConnection.ssid;
+                root.addDebugInfo(qsTr("Connection profile created successfully, now activating: %1").arg(ssid));
+                root.setConnectionStatus(qsTr("Activating connection..."));
+                
+                // Update saved connections list since we just created one
+                listConnectionsProc.running = true;
+                
+                // Activate the connection we just created
+                connectProc.command = ["nmcli", "connection", "up", ssid];
+                Qt.callLater(() => {
+                    connectProc.running = true;
+                });
+                // Don't start timers yet - wait for activation to complete
+                return;
+            }
+            
             // Refresh network list after connection attempt
             getNetworks.running = true;
             
             // Check if connection succeeded after a short delay (network list needs to update)
             if (root.pendingConnection) {
-                immediateCheckTimer.start();
+                if (exitCode === 0) {
+                    // Process succeeded, start checking connection status
+                    root.setConnectionStatus(qsTr("Connection command succeeded, verifying..."));
+                    root.addDebugInfo(qsTr("Command succeeded, checking connection status..."));
+                    root.addDebugInfo(qsTr("Starting immediate check timer (500ms intervals)"));
+                    immediateCheckTimer.start();
+                } else {
+                    // Process failed, but wait a moment to see if connection still works
+                    root.setConnectionStatus(qsTr("Connection command exited with code %1, checking status...").arg(exitCode));
+                    root.addDebugInfo(qsTr("Command exited with error code %1").arg(exitCode));
+                    root.addDebugInfo(qsTr("This usually means the command failed"));
+                    root.addDebugInfo(qsTr("Checking connection status anyway..."));
+                    root.addDebugInfo(qsTr("Starting immediate check timer (500ms intervals)"));
+                    immediateCheckTimer.start();
+                }
+            } else {
+                root.addDebugInfo(qsTr("No pending connection - not starting immediate check timer"));
             }
+            root.addDebugInfo(qsTr("======================"));
         }
         stdout: SplitParser {
-            onRead: getNetworks.running = true
+            onRead: {
+                getNetworks.running = true;
+                // Also log output for debugging
+                if (text && text.trim().length > 0) {
+                    root.addDebugInfo(qsTr("STDOUT: %1").arg(text.trim()));
+                    root.setConnectionStatus(qsTr("Status: %1").arg(text.trim()));
+                }
+            }
         }
         stderr: StdioCollector {
             onStreamFinished: {
                 const error = text.trim();
+                root.addDebugInfo(qsTr("=== STDERR OUTPUT ==="));
                 if (error && error.length > 0) {
+                    // Split error into lines and add each one
+                    const errorLines = error.split("\n");
+                    for (let i = 0; i < errorLines.length; i++) {
+                        const line = errorLines[i].trim();
+                        if (line.length > 0) {
+                            root.addDebugInfo(qsTr("STDERR: %1").arg(line));
+                        }
+                    }
+                    
                     // Check for specific errors that indicate password is needed
                     // Be careful not to match success messages
                     const needsPassword = (error.includes("Secrets were required") || 
@@ -270,11 +530,19 @@ Singleton {
                         const pending = root.pendingConnection;
                         root.pendingConnection = null;
                         pending.callback();
-                    } else if (error && error.length > 0 && !error.includes("Connection activated")) {
-                        // Only log non-success messages
-                        console.warn("Network connection error:", error);
+                    } else if (error && error.length > 0 && !error.includes("Connection activated") && !error.includes("successfully")) {
+                        // Log all errors (except success messages)
+                        root.setConnectionStatus(qsTr("Error: %1").arg(errorLines[0] || error));
+                        // Emit signal for UI to handle
+                        root.connectionFailed(root.pendingConnection ? root.pendingConnection.ssid : "");
+                    } else if (error && (error.includes("Connection activated") || error.includes("successfully"))) {
+                        root.addDebugInfo(qsTr("Connection successful!"));
+                        root.setConnectionStatus(qsTr("Connection successful!"));
                     }
+                } else {
+                    root.addDebugInfo(qsTr("STDERR: (empty)"));
                 }
+                root.addDebugInfo(qsTr("===================="));
             }
         }
     }
@@ -322,6 +590,26 @@ Singleton {
     }
 
     Process {
+        id: deleteConnectionProc
+        
+        // Delete connection profile - refresh network list and saved connections after deletion
+        onExited: {
+            // Refresh network list and saved connections after deletion
+            getNetworks.running = true;
+            listConnectionsProc.running = true;
+        }
+        stderr: StdioCollector {
+            onStreamFinished: {
+                const error = text.trim();
+                if (error && error.length > 0) {
+                    // Log error but don't fail - connection might not exist
+                    console.warn("Network connection delete error:", error);
+                }
+            }
+        }
+    }
+
+    Process {
         id: getNetworks
 
         running: true