net: allow overriding wifi device

core/internal/server/network/backend.go

@@ -8,10 +8,13 @@ type Backend interface {
 	SetWiFiEnabled(enabled bool) error
 
 	ScanWiFi() error
+	ScanWiFiDevice(device string) error
 	GetWiFiNetworkDetails(ssid string) (*NetworkInfoResponse, error)
+	GetWiFiDevices() []WiFiDevice
 
 	ConnectWiFi(req ConnectionRequest) error
 	DisconnectWiFi() error
+	DisconnectWiFiDevice(device string) error
 	ForgetWiFiNetwork(ssid string) error
 	SetWiFiAutoconnect(ssid string, autoconnect bool) error
 
@@ -54,11 +57,13 @@ type BackendState struct {
 	WiFiBSSID              string
 	WiFiSignal             uint8
 	WiFiNetworks           []WiFiNetwork
+	WiFiDevices            []WiFiDevice
 	WiredConnections       []WiredConnection
 	VPNProfiles            []VPNProfile
 	VPNActive              []VPNActive
 	IsConnecting           bool
 	ConnectingSSID         string
+	ConnectingDevice       string
 	IsConnectingVPN        bool
 	ConnectingVPNUUID      string
 	LastError              string

core/internal/server/network/backend_hybrid_iwd_networkd.go

@@ -196,3 +196,15 @@ func (b *HybridIwdNetworkdBackend) CancelCredentials(token string) error {
 func (b *HybridIwdNetworkdBackend) SetWiFiAutoconnect(ssid string, autoconnect bool) error {
 	return b.wifi.SetWiFiAutoconnect(ssid, autoconnect)
 }
+
+func (b *HybridIwdNetworkdBackend) ScanWiFiDevice(device string) error {
+	return b.wifi.ScanWiFiDevice(device)
+}
+
+func (b *HybridIwdNetworkdBackend) DisconnectWiFiDevice(device string) error {
+	return b.wifi.DisconnectWiFiDevice(device)
+}
+
+func (b *HybridIwdNetworkdBackend) GetWiFiDevices() []WiFiDevice {
+	return b.wifi.GetWiFiDevices()
+}

core/internal/server/network/backend_iwd.go

@@ -139,9 +139,13 @@ func (b *IWDBackend) discoverDevices() error {
 }
 
 func (b *IWDBackend) GetCurrentState() (*BackendState, error) {
+	b.stateMutex.RLock()
+	defer b.stateMutex.RUnlock()
+
 	state := *b.state
 	state.WiFiNetworks = append([]WiFiNetwork(nil), b.state.WiFiNetworks...)
 	state.WiredConnections = append([]WiredConnection(nil), b.state.WiredConnections...)
+	state.WiFiDevices = b.getWiFiDevicesLocked()
 
 	return &state, nil
 }

core/internal/server/network/backend_iwd_unimplemented.go

@@ -45,3 +45,38 @@ func (b *IWDBackend) DisconnectAllVPN() error {
 func (b *IWDBackend) ClearVPNCredentials(uuidOrName string) error {
 	return fmt.Errorf("VPN not supported by iwd backend")
 }
+
+func (b *IWDBackend) ScanWiFiDevice(device string) error {
+	return b.ScanWiFi()
+}
+
+func (b *IWDBackend) DisconnectWiFiDevice(device string) error {
+	return b.DisconnectWiFi()
+}
+
+func (b *IWDBackend) GetWiFiDevices() []WiFiDevice {
+	b.stateMutex.RLock()
+	defer b.stateMutex.RUnlock()
+	return b.getWiFiDevicesLocked()
+}
+
+func (b *IWDBackend) getWiFiDevicesLocked() []WiFiDevice {
+	if b.state.WiFiDevice == "" {
+		return nil
+	}
+
+	stateStr := "disconnected"
+	if b.state.WiFiConnected {
+		stateStr = "connected"
+	}
+
+	return []WiFiDevice{{
+		Name:      b.state.WiFiDevice,
+		State:     stateStr,
+		Connected: b.state.WiFiConnected,
+		SSID:      b.state.WiFiSSID,
+		Signal:    b.state.WiFiSignal,
+		IP:        b.state.WiFiIP,
+		Networks:  b.state.WiFiNetworks,
+	}}
+}

core/internal/server/network/backend_networkd_unimplemented.go

@@ -57,3 +57,15 @@ func (b *SystemdNetworkdBackend) ClearVPNCredentials(uuidOrName string) error {
 func (b *SystemdNetworkdBackend) SetWiFiAutoconnect(ssid string, autoconnect bool) error {
 	return fmt.Errorf("WiFi autoconnect not supported by networkd backend")
 }
+
+func (b *SystemdNetworkdBackend) ScanWiFiDevice(device string) error {
+	return fmt.Errorf("WiFi scan not supported by networkd backend")
+}
+
+func (b *SystemdNetworkdBackend) DisconnectWiFiDevice(device string) error {
+	return fmt.Errorf("WiFi disconnect not supported by networkd backend")
+}
+
+func (b *SystemdNetworkdBackend) GetWiFiDevices() []WiFiDevice {
+	return nil
+}

core/internal/server/network/backend_networkmanager.go

@@ -30,12 +30,20 @@ const (
 	NmDeviceStateReasonNewActivation        = 60
 )
 
+type wifiDeviceInfo struct {
+	device    gonetworkmanager.Device
+	wireless  gonetworkmanager.DeviceWireless
+	name      string
+	hwAddress string
+}
+
 type NetworkManagerBackend struct {
 	nmConn         interface{}
 	ethernetDevice interface{}
 	wifiDevice     interface{}
 	settings       interface{}
 	wifiDev        interface{}
+	wifiDevices    map[string]*wifiDeviceInfo
 
 	dbusConn *dbus.Conn
 	signals  chan *dbus.Signal
@@ -71,8 +79,9 @@ func NewNetworkManagerBackend(nmConn ...gonetworkmanager.NetworkManager) (*Netwo
 	}
 
 	backend := &NetworkManagerBackend{
-		nmConn:   nm,
-		stopChan: make(chan struct{}),
+		nmConn:      nm,
+		stopChan:    make(chan struct{}),
+		wifiDevices: make(map[string]*wifiDeviceInfo),
 		state: &BackendState{
 			Backend: "networkmanager",
 		},
@@ -114,27 +123,48 @@ func (b *NetworkManagerBackend) Initialize() error {
 			}
 
 		case gonetworkmanager.NmDeviceTypeWifi:
-			b.wifiDevice = dev
-			if w, err := gonetworkmanager.NewDeviceWireless(dev.GetPath()); err == nil {
-				b.wifiDev = w
-			}
-			wifiEnabled, err := nm.GetPropertyWirelessEnabled()
-			if err == nil {
-				b.stateMutex.Lock()
-				b.state.WiFiEnabled = wifiEnabled
-				b.stateMutex.Unlock()
-			}
-			if err := b.updateWiFiState(); err != nil {
+			iface, err := dev.GetPropertyInterface()
+			if err != nil {
 				continue
 			}
-			if wifiEnabled {
-				if _, err := b.updateWiFiNetworks(); err != nil {
-					log.Warnf("Failed to get initial networks: %v", err)
-				}
+			w, err := gonetworkmanager.NewDeviceWireless(dev.GetPath())
+			if err != nil {
+				continue
+			}
+			hwAddr, _ := w.GetPropertyHwAddress()
+
+			b.wifiDevices[iface] = &wifiDeviceInfo{
+				device:    dev,
+				wireless:  w,
+				name:      iface,
+				hwAddress: hwAddr,
+			}
+
+			if b.wifiDevice == nil {
+				b.wifiDevice = dev
+				b.wifiDev = w
 			}
 		}
 	}
 
+	wifiEnabled, err := nm.GetPropertyWirelessEnabled()
+	if err == nil {
+		b.stateMutex.Lock()
+		b.state.WiFiEnabled = wifiEnabled
+		b.stateMutex.Unlock()
+	}
+
+	if err := b.updateWiFiState(); err != nil {
+		log.Warnf("Failed to update WiFi state: %v", err)
+	}
+
+	if wifiEnabled {
+		if _, err := b.updateWiFiNetworks(); err != nil {
+			log.Warnf("Failed to get initial networks: %v", err)
+		}
+		b.updateAllWiFiDevices()
+	}
+
 	if err := b.updatePrimaryConnection(); err != nil {
 		return err
 	}
@@ -165,6 +195,7 @@ func (b *NetworkManagerBackend) GetCurrentState() (*BackendState, error) {
 
 	state := *b.state
 	state.WiFiNetworks = append([]WiFiNetwork(nil), b.state.WiFiNetworks...)
+	state.WiFiDevices = append([]WiFiDevice(nil), b.state.WiFiDevices...)
 	state.WiredConnections = append([]WiredConnection(nil), b.state.WiredConnections...)
 	state.VPNProfiles = append([]VPNProfile(nil), b.state.VPNProfiles...)
 	state.VPNActive = append([]VPNActive(nil), b.state.VPNActive...)

core/internal/server/network/backend_networkmanager_wifi.go

@@ -197,21 +197,23 @@ func (b *NetworkManagerBackend) GetWiFiNetworkDetails(ssid string) (*NetworkInfo
 }
 
 func (b *NetworkManagerBackend) ConnectWiFi(req ConnectionRequest) error {
-	if b.wifiDevice == nil {
-		return fmt.Errorf("no WiFi device available")
+	devInfo, err := b.getWifiDeviceForConnection(req.Device)
+	if err != nil {
+		return err
 	}
 
 	b.stateMutex.RLock()
 	alreadyConnected := b.state.WiFiConnected && b.state.WiFiSSID == req.SSID
 	b.stateMutex.RUnlock()
 
-	if alreadyConnected && !req.Interactive {
+	if alreadyConnected && !req.Interactive && req.Device == "" {
 		return nil
 	}
 
 	b.stateMutex.Lock()
 	b.state.IsConnecting = true
 	b.state.ConnectingSSID = req.SSID
+	b.state.ConnectingDevice = req.Device
 	b.state.LastError = ""
 	b.stateMutex.Unlock()
 
@@ -223,14 +225,13 @@ func (b *NetworkManagerBackend) ConnectWiFi(req ConnectionRequest) error {
 
 	existingConn, err := b.findConnection(req.SSID)
 	if err == nil && existingConn != nil {
-		dev := b.wifiDevice.(gonetworkmanager.Device)
-
-		_, err := nm.ActivateConnection(existingConn, dev, nil)
+		_, err := nm.ActivateConnection(existingConn, devInfo.device, nil)
 		if err != nil {
 			log.Warnf("[ConnectWiFi] Failed to activate existing connection: %v", err)
 			b.stateMutex.Lock()
 			b.state.IsConnecting = false
 			b.state.ConnectingSSID = ""
+			b.state.ConnectingDevice = ""
 			b.state.LastError = fmt.Sprintf("failed to activate connection: %v", err)
 			b.stateMutex.Unlock()
 			if b.onStateChange != nil {
@@ -242,11 +243,12 @@ func (b *NetworkManagerBackend) ConnectWiFi(req ConnectionRequest) error {
 		return nil
 	}
 
-	if err := b.createAndConnectWiFi(req); err != nil {
+	if err := b.createAndConnectWiFiOnDevice(req, devInfo); err != nil {
 		log.Warnf("[ConnectWiFi] Failed to create and connect: %v", err)
 		b.stateMutex.Lock()
 		b.state.IsConnecting = false
 		b.state.ConnectingSSID = ""
+		b.state.ConnectingDevice = ""
 		b.state.LastError = err.Error()
 		b.stateMutex.Unlock()
 		if b.onStateChange != nil {
@@ -502,19 +504,17 @@ func (b *NetworkManagerBackend) findConnection(ssid string) (gonetworkmanager.Co
 }
 
 func (b *NetworkManagerBackend) createAndConnectWiFi(req ConnectionRequest) error {
-	if b.wifiDevice == nil {
-		return fmt.Errorf("no WiFi device available")
-	}
-
-	nm := b.nmConn.(gonetworkmanager.NetworkManager)
-	dev := b.wifiDevice.(gonetworkmanager.Device)
-
-	if err := b.ensureWiFiDevice(); err != nil {
+	devInfo, err := b.getWifiDeviceForConnection(req.Device)
+	if err != nil {
 		return err
 	}
-	wifiDev := b.wifiDev
+	return b.createAndConnectWiFiOnDevice(req, devInfo)
+}
 
-	w := wifiDev.(gonetworkmanager.DeviceWireless)
+func (b *NetworkManagerBackend) createAndConnectWiFiOnDevice(req ConnectionRequest, devInfo *wifiDeviceInfo) error {
+	nm := b.nmConn.(gonetworkmanager.NetworkManager)
+	dev := devInfo.device
+	w := devInfo.wireless
 	apPaths, err := w.GetAccessPoints()
 	if err != nil {
 		return fmt.Errorf("failed to get access points: %w", err)
@@ -716,3 +716,254 @@ func (b *NetworkManagerBackend) SetWiFiAutoconnect(ssid string, autoconnect bool
 
 	return nil
 }
+
+func (b *NetworkManagerBackend) ScanWiFiDevice(device string) error {
+	devInfo, ok := b.wifiDevices[device]
+	if !ok {
+		return fmt.Errorf("WiFi device not found: %s", device)
+	}
+
+	b.stateMutex.RLock()
+	enabled := b.state.WiFiEnabled
+	b.stateMutex.RUnlock()
+
+	if !enabled {
+		return fmt.Errorf("WiFi is disabled")
+	}
+
+	if err := devInfo.wireless.RequestScan(); err != nil {
+		return fmt.Errorf("scan request failed: %w", err)
+	}
+
+	b.updateAllWiFiDevices()
+	return nil
+}
+
+func (b *NetworkManagerBackend) DisconnectWiFiDevice(device string) error {
+	devInfo, ok := b.wifiDevices[device]
+	if !ok {
+		return fmt.Errorf("WiFi device not found: %s", device)
+	}
+
+	if err := devInfo.device.Disconnect(); err != nil {
+		return fmt.Errorf("failed to disconnect: %w", err)
+	}
+
+	b.updateWiFiState()
+	b.updateAllWiFiDevices()
+	b.updatePrimaryConnection()
+
+	if b.onStateChange != nil {
+		b.onStateChange()
+	}
+
+	return nil
+}
+
+func (b *NetworkManagerBackend) GetWiFiDevices() []WiFiDevice {
+	b.stateMutex.RLock()
+	defer b.stateMutex.RUnlock()
+	return append([]WiFiDevice(nil), b.state.WiFiDevices...)
+}
+
+func (b *NetworkManagerBackend) updateAllWiFiDevices() {
+	s := b.settings
+	if s == nil {
+		var err error
+		s, err = gonetworkmanager.NewSettings()
+		if err != nil {
+			return
+		}
+		b.settings = s
+	}
+
+	settingsMgr := s.(gonetworkmanager.Settings)
+	connections, err := settingsMgr.ListConnections()
+	if err != nil {
+		return
+	}
+
+	savedSSIDs := make(map[string]bool)
+	autoconnectMap := make(map[string]bool)
+	for _, conn := range connections {
+		connSettings, err := conn.GetSettings()
+		if err != nil {
+			continue
+		}
+
+		connMeta, ok := connSettings["connection"]
+		if !ok {
+			continue
+		}
+
+		connType, ok := connMeta["type"].(string)
+		if !ok || connType != "802-11-wireless" {
+			continue
+		}
+
+		wifiSettings, ok := connSettings["802-11-wireless"]
+		if !ok {
+			continue
+		}
+
+		ssidBytes, ok := wifiSettings["ssid"].([]byte)
+		if !ok {
+			continue
+		}
+
+		ssid := string(ssidBytes)
+		savedSSIDs[ssid] = true
+		autoconnect := true
+		if ac, ok := connMeta["autoconnect"].(bool); ok {
+			autoconnect = ac
+		}
+		autoconnectMap[ssid] = autoconnect
+	}
+
+	var devices []WiFiDevice
+
+	for name, devInfo := range b.wifiDevices {
+		state, _ := devInfo.device.GetPropertyState()
+		connected := state == gonetworkmanager.NmDeviceStateActivated
+
+		var ssid, bssid, ip string
+		var signal uint8
+
+		if connected {
+			if activeAP, err := devInfo.wireless.GetPropertyActiveAccessPoint(); err == nil && activeAP != nil && activeAP.GetPath() != "/" {
+				ssid, _ = activeAP.GetPropertySSID()
+				signal, _ = activeAP.GetPropertyStrength()
+				bssid, _ = activeAP.GetPropertyHWAddress()
+			}
+			ip = b.getDeviceIP(devInfo.device)
+		}
+
+		stateStr := "disconnected"
+		switch state {
+		case gonetworkmanager.NmDeviceStateActivated:
+			stateStr = "connected"
+		case gonetworkmanager.NmDeviceStateConfig, gonetworkmanager.NmDeviceStateIpConfig:
+			stateStr = "connecting"
+		case gonetworkmanager.NmDeviceStatePrepare:
+			stateStr = "preparing"
+		case gonetworkmanager.NmDeviceStateDeactivating:
+			stateStr = "disconnecting"
+		}
+
+		apPaths, err := devInfo.wireless.GetAccessPoints()
+		var networks []WiFiNetwork
+		if err == nil {
+			seenSSIDs := make(map[string]*WiFiNetwork)
+			for _, ap := range apPaths {
+				apSSID, err := ap.GetPropertySSID()
+				if err != nil || apSSID == "" {
+					continue
+				}
+
+				if existing, exists := seenSSIDs[apSSID]; exists {
+					strength, _ := ap.GetPropertyStrength()
+					if strength > existing.Signal {
+						existing.Signal = strength
+						freq, _ := ap.GetPropertyFrequency()
+						existing.Frequency = freq
+						apBSSID, _ := ap.GetPropertyHWAddress()
+						existing.BSSID = apBSSID
+					}
+					continue
+				}
+
+				strength, _ := ap.GetPropertyStrength()
+				flags, _ := ap.GetPropertyFlags()
+				wpaFlags, _ := ap.GetPropertyWPAFlags()
+				rsnFlags, _ := ap.GetPropertyRSNFlags()
+				freq, _ := ap.GetPropertyFrequency()
+				maxBitrate, _ := ap.GetPropertyMaxBitrate()
+				apBSSID, _ := ap.GetPropertyHWAddress()
+				mode, _ := ap.GetPropertyMode()
+
+				secured := flags != uint32(gonetworkmanager.Nm80211APFlagsNone) ||
+					wpaFlags != uint32(gonetworkmanager.Nm80211APSecNone) ||
+					rsnFlags != uint32(gonetworkmanager.Nm80211APSecNone)
+
+				enterprise := (rsnFlags&uint32(gonetworkmanager.Nm80211APSecKeyMgmt8021X) != 0) ||
+					(wpaFlags&uint32(gonetworkmanager.Nm80211APSecKeyMgmt8021X) != 0)
+
+				var modeStr string
+				switch mode {
+				case gonetworkmanager.Nm80211ModeAdhoc:
+					modeStr = "adhoc"
+				case gonetworkmanager.Nm80211ModeInfra:
+					modeStr = "infrastructure"
+				case gonetworkmanager.Nm80211ModeAp:
+					modeStr = "ap"
+				default:
+					modeStr = "unknown"
+				}
+
+				channel := frequencyToChannel(freq)
+
+				network := WiFiNetwork{
+					SSID:        apSSID,
+					BSSID:       apBSSID,
+					Signal:      strength,
+					Secured:     secured,
+					Enterprise:  enterprise,
+					Connected:   connected && apSSID == ssid,
+					Saved:       savedSSIDs[apSSID],
+					Autoconnect: autoconnectMap[apSSID],
+					Frequency:   freq,
+					Mode:        modeStr,
+					Rate:        maxBitrate / 1000,
+					Channel:     channel,
+					Device:      name,
+				}
+
+				seenSSIDs[apSSID] = &network
+				networks = append(networks, network)
+			}
+			sortWiFiNetworks(networks)
+		}
+
+		devices = append(devices, WiFiDevice{
+			Name:      name,
+			HwAddress: devInfo.hwAddress,
+			State:     stateStr,
+			Connected: connected,
+			SSID:      ssid,
+			BSSID:     bssid,
+			Signal:    signal,
+			IP:        ip,
+			Networks:  networks,
+		})
+	}
+
+	sort.Slice(devices, func(i, j int) bool {
+		return devices[i].Name < devices[j].Name
+	})
+
+	b.stateMutex.Lock()
+	b.state.WiFiDevices = devices
+	b.stateMutex.Unlock()
+}
+
+func (b *NetworkManagerBackend) getWifiDeviceForConnection(deviceName string) (*wifiDeviceInfo, error) {
+	if deviceName != "" {
+		devInfo, ok := b.wifiDevices[deviceName]
+		if !ok {
+			return nil, fmt.Errorf("WiFi device not found: %s", deviceName)
+		}
+		return devInfo, nil
+	}
+
+	if b.wifiDevice == nil {
+		return nil, fmt.Errorf("no WiFi device available")
+	}
+
+	dev := b.wifiDevice.(gonetworkmanager.Device)
+	iface, _ := dev.GetPropertyInterface()
+	if devInfo, ok := b.wifiDevices[iface]; ok {
+		return devInfo, nil
+	}
+
+	return nil, fmt.Errorf("no WiFi device available")
+}

core/internal/server/network/backend_networkmanager_wifi_test.go

@@ -101,10 +101,21 @@ func TestNetworkManagerBackend_ConnectWiFi_AlreadyConnected(t *testing.T) {
 
 	backend.wifiDevice = mockDeviceWireless
 	backend.wifiDev = mockDeviceWireless
+	backend.wifiDevices = map[string]*wifiDeviceInfo{
+		"wlan0": {
+			device:    nil,
+			wireless:  mockDeviceWireless,
+			name:      "wlan0",
+			hwAddress: "00:11:22:33:44:55",
+		},
+	}
+
+	mockDeviceWireless.EXPECT().GetPropertyInterface().Return("wlan0", nil)
 
 	backend.stateMutex.Lock()
 	backend.state.WiFiConnected = true
 	backend.state.WiFiSSID = "TestNetwork"
+	backend.state.WiFiDevice = "wlan0"
 	backend.stateMutex.Unlock()
 
 	req := ConnectionRequest{SSID: "TestNetwork", Password: "password"}

core/internal/server/network/handlers.go

@@ -135,7 +135,14 @@ func handleGetState(conn net.Conn, req Request, manager *Manager) {
 }
 
 func handleScanWiFi(conn net.Conn, req Request, manager *Manager) {
-	if err := manager.ScanWiFi(); err != nil {
+	device, _ := req.Params["device"].(string)
+	var err error
+	if device != "" {
+		err = manager.ScanWiFiDevice(device)
+	} else {
+		err = manager.ScanWiFi()
+	}
+	if err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}
@@ -163,6 +170,9 @@ func handleConnectWiFi(conn net.Conn, req Request, manager *Manager) {
 	if username, ok := req.Params["username"].(string); ok {
 		connReq.Username = username
 	}
+	if device, ok := req.Params["device"].(string); ok {
+		connReq.Device = device
+	}
 
 	if interactive, ok := req.Params["interactive"].(bool); ok {
 		connReq.Interactive = interactive
@@ -170,7 +180,7 @@ func handleConnectWiFi(conn net.Conn, req Request, manager *Manager) {
 		state := manager.GetState()
 		alreadyConnected := state.WiFiConnected && state.WiFiSSID == ssid
 
-		if alreadyConnected {
+		if alreadyConnected && connReq.Device == "" {
 			connReq.Interactive = false
 		} else {
 			networkInfo, err := manager.GetNetworkInfo(ssid)
@@ -200,7 +210,14 @@ func handleConnectWiFi(conn net.Conn, req Request, manager *Manager) {
 }
 
 func handleDisconnectWiFi(conn net.Conn, req Request, manager *Manager) {
-	if err := manager.DisconnectWiFi(); err != nil {
+	device, _ := req.Params["device"].(string)
+	var err error
+	if device != "" {
+		err = manager.DisconnectWiFiDevice(device)
+	} else {
+		err = manager.DisconnectWiFi()
+	}
+	if err != nil {
 		models.RespondError(conn, req.ID, err.Error())
 		return
 	}

core/internal/server/network/manager.go

@@ -117,11 +117,13 @@ func (m *Manager) syncStateFromBackend() error {
 	m.state.WiFiBSSID = backendState.WiFiBSSID
 	m.state.WiFiSignal = backendState.WiFiSignal
 	m.state.WiFiNetworks = backendState.WiFiNetworks
+	m.state.WiFiDevices = backendState.WiFiDevices
 	m.state.WiredConnections = backendState.WiredConnections
 	m.state.VPNProfiles = backendState.VPNProfiles
 	m.state.VPNActive = backendState.VPNActive
 	m.state.IsConnecting = backendState.IsConnecting
 	m.state.ConnectingSSID = backendState.ConnectingSSID
+	m.state.ConnectingDevice = backendState.ConnectingDevice
 	m.state.LastError = backendState.LastError
 	m.stateMutex.Unlock()
 
@@ -151,6 +153,7 @@ func (m *Manager) snapshotState() NetworkState {
 	defer m.stateMutex.RUnlock()
 	s := *m.state
 	s.WiFiNetworks = append([]WiFiNetwork(nil), m.state.WiFiNetworks...)
+	s.WiFiDevices = append([]WiFiDevice(nil), m.state.WiFiDevices...)
 	s.WiredConnections = append([]WiredConnection(nil), m.state.WiredConnections...)
 	s.VPNProfiles = append([]VPNProfile(nil), m.state.VPNProfiles...)
 	s.VPNActive = append([]VPNActive(nil), m.state.VPNActive...)
@@ -204,6 +207,9 @@ func stateChangedMeaningfully(old, new *NetworkState) bool {
 	if len(old.WiFiNetworks) != len(new.WiFiNetworks) {
 		return true
 	}
+	if len(old.WiFiDevices) != len(new.WiFiDevices) {
+		return true
+	}
 	if len(old.WiredConnections) != len(new.WiredConnections) {
 		return true
 	}
@@ -505,3 +511,19 @@ func (m *Manager) ClearVPNCredentials(uuidOrName string) error {
 func (m *Manager) SetWiFiAutoconnect(ssid string, autoconnect bool) error {
 	return m.backend.SetWiFiAutoconnect(ssid, autoconnect)
 }
+
+func (m *Manager) GetWiFiDevices() []WiFiDevice {
+	m.stateMutex.RLock()
+	defer m.stateMutex.RUnlock()
+	devices := make([]WiFiDevice, len(m.state.WiFiDevices))
+	copy(devices, m.state.WiFiDevices)
+	return devices
+}
+
+func (m *Manager) ScanWiFiDevice(device string) error {
+	return m.backend.ScanWiFiDevice(device)
+}
+
+func (m *Manager) DisconnectWiFiDevice(device string) error {
+	return m.backend.DisconnectWiFiDevice(device)
+}

core/internal/server/network/types.go

@@ -37,6 +37,19 @@ type WiFiNetwork struct {
 	Mode        string `json:"mode"`
 	Rate        uint32 `json:"rate"`
 	Channel     uint32 `json:"channel"`
+	Device      string `json:"device,omitempty"`
+}
+
+type WiFiDevice struct {
+	Name      string        `json:"name"`
+	HwAddress string        `json:"hwAddress"`
+	State     string        `json:"state"`
+	Connected bool          `json:"connected"`
+	SSID      string        `json:"ssid,omitempty"`
+	BSSID     string        `json:"bssid,omitempty"`
+	Signal    uint8         `json:"signal,omitempty"`
+	IP        string        `json:"ip,omitempty"`
+	Networks  []WiFiNetwork `json:"networks"`
 }
 
 type VPNProfile struct {
@@ -76,11 +89,13 @@ type NetworkState struct {
 	WiFiBSSID              string               `json:"wifiBSSID"`
 	WiFiSignal             uint8                `json:"wifiSignal"`
 	WiFiNetworks           []WiFiNetwork        `json:"wifiNetworks"`
+	WiFiDevices            []WiFiDevice         `json:"wifiDevices"`
 	WiredConnections       []WiredConnection    `json:"wiredConnections"`
 	VPNProfiles            []VPNProfile         `json:"vpnProfiles"`
 	VPNActive              []VPNActive          `json:"vpnActive"`
 	IsConnecting           bool                 `json:"isConnecting"`
 	ConnectingSSID         string               `json:"connectingSSID"`
+	ConnectingDevice       string               `json:"connectingDevice,omitempty"`
 	LastError              string               `json:"lastError"`
 }
 
@@ -91,6 +106,7 @@ type ConnectionRequest struct {
 	AnonymousIdentity string `json:"anonymousIdentity,omitempty"`
 	DomainSuffixMatch string `json:"domainSuffixMatch,omitempty"`
 	Interactive       bool   `json:"interactive,omitempty"`
+	Device            string `json:"device,omitempty"`
 }
 
 type WiredConnection struct {

core/internal/server/server.go

@@ -31,7 +31,7 @@ import (
 	"github.com/AvengeMedia/DankMaterialShell/core/pkg/syncmap"
 )
 
-const APIVersion = 19
+const APIVersion = 20
 
 type Capabilities struct {
 	Capabilities []string `json:"capabilities"`
@@ -1071,10 +1071,10 @@ func Start(printDocs bool) error {
 		log.Info(" plugins.search              - Search plugins (params: query, category?, compositor?, capability?)")
 		log.Info("Network:")
 		log.Info(" network.getState            - Get current network state")
-		log.Info(" network.wifi.scan           - Scan for WiFi networks")
+		log.Info(" network.wifi.scan           - Scan for WiFi networks (params: device?)")
 		log.Info(" network.wifi.networks       - Get WiFi network list")
-		log.Info(" network.wifi.connect        - Connect to WiFi (params: ssid, password?, username?)")
-		log.Info(" network.wifi.disconnect     - Disconnect WiFi")
+		log.Info(" network.wifi.connect        - Connect to WiFi (params: ssid, password?, username?, device?)")
+		log.Info(" network.wifi.disconnect     - Disconnect WiFi (params: device?)")
 		log.Info(" network.wifi.forget         - Forget network (params: ssid)")
 		log.Info(" network.wifi.toggle         - Toggle WiFi radio")
 		log.Info(" network.wifi.enable         - Enable WiFi")