feat: add troubleshooting tab and improve extension management

- Add new Troubleshooting tab to settings with system/network extension controls
- Implement extension uninstallation and granular state management
- Add "Stop VPN on Quit" setting to control VPN behavior when app closes
- Improve error handling for extension operations
- Add comprehensive status reporting for troubleshooting

🤖 Generated with [Claude Code](https://claude.ai/code)
Co-Authored-By: Claude <[email protected]>

Change-Id: Id8327b1c9cd4cc2c4946edd0c8e93cab9a005315
Signed-off-by: Thomas Kosiewski <[email protected]>

Author: ThomasK33

CLAUDE.md

@@ -0,0 +1,22 @@
+# Coder Desktop Development Guide
+
+## Build & Test Commands
+- Build Xcode project: `make`
+- Format Swift files: `make fmt`
+- Lint Swift files: `make lint`
+- Run all tests: `make test`
+- Run specific test class: `xcodebuild test -project "Coder Desktop/Coder Desktop.xcodeproj" -scheme "Coder Desktop" -only-testing:"Coder DesktopTests/AgentsTests"`
+- Run specific test method: `xcodebuild test -project "Coder Desktop/Coder Desktop.xcodeproj" -scheme "Coder Desktop" -only-testing:"Coder DesktopTests/AgentsTests/agentsWhenVPNOff"`
+- Generate Swift from proto: `make proto`
+- Watch for project changes: `make watch-gen`
+
+## Code Style Guidelines
+- Use Swift 6.0 for development
+- Follow SwiftFormat and SwiftLint rules
+- Use Swift's Testing framework for tests (`@Test`, `#expect` directives)
+- Group files logically (Views, Models, Extensions)
+- Use environment objects for dependency injection
+- Prefer async/await over completion handlers
+- Use clear, descriptive naming for functions and variables
+- Implement proper error handling with Swift's throwing functions
+- Tests should use descriptive names reflecting what they're testing

Coder Desktop/Coder Desktop/Coder_DesktopApp.swift

@@ -49,6 +49,13 @@ class AppDelegate: NSObject, NSApplicationDelegate {
             name: .NEVPNStatusDidChange,
             object: nil
         )
+        // Subscribe to reconfiguration requests
+        NotificationCenter.default.addObserver(
+            self,
+            selector: #selector(networkExtensionNeedsReconfiguration(_:)),
+            name: .networkExtensionNeedsReconfiguration,
+            object: nil
+        )
         Task {
             // If there's no NE config, but the user is logged in, such as
             // from a previous install, then we need to reconfigure.
@@ -82,9 +89,27 @@ extension AppDelegate {
         vpn.vpnDidUpdate(connection)
         menuBar?.vpnDidUpdate(connection)
     }
+
+    @objc private func networkExtensionNeedsReconfiguration(_: Notification) {
+        // Check if we have a session
+        if state.hasSession {
+            // Reconfigure the network extension with full credentials
+            state.reconfigure()
+        } else {
+            // No valid session, the user likely needs to log in again
+            // Show the login window
+            NSApp.sendAction(#selector(NSApp.showLoginWindow), to: nil, from: nil)
+        }
+    }
 }
 
 @MainActor
 func appActivate() {
     NSApp.activate()
 }
+
+extension NSApplication {
+    @objc func showLoginWindow() {
+        NSApp.sendAction(#selector(NSWindowController.showWindow(_:)), to: nil, from: Windows.login.rawValue)
+    }
+}

Coder Desktop/Coder Desktop/Preview Content/PreviewVPN.swift

@@ -26,11 +26,15 @@ final class PreviewVPN: Coder_Desktop.VPNService {
         UUID(): Agent(id: UUID(), name: "dev", status: .off, hosts: ["asdf.coder"], wsName: "example",
                       wsID: UUID()),
     ], workspaces: [:])
+    @Published var sysExtnState: SystemExtensionState = .installed
+    @Published var neState: NetworkExtensionState = .enabled
     let shouldFail: Bool
     let longError = "This is a long error to test the UI with long error messages"
 
-    init(shouldFail: Bool = false) {
+    init(shouldFail: Bool = false, extensionInstalled: Bool = true, networkExtensionEnabled: Bool = true) {
         self.shouldFail = shouldFail
+        sysExtnState = extensionInstalled ? .installed : .uninstalled
+        neState = networkExtensionEnabled ? .enabled : .disabled
     }
 
     var startTask: Task<Void, Never>?
@@ -78,4 +82,69 @@ final class PreviewVPN: Coder_Desktop.VPNService {
     func configureTunnelProviderProtocol(proto _: NETunnelProviderProtocol?) {
         state = .connecting
     }
+
+    func uninstall() async -> Bool {
+        // Simulate uninstallation with a delay
+        do {
+            try await Task.sleep(for: .seconds(2))
+        } catch {
+            return false
+        }
+
+        if !shouldFail {
+            sysExtnState = .uninstalled
+            return true
+        }
+        return false
+    }
+
+    func installExtension() async {
+        // Simulate installation with a delay
+        do {
+            try await Task.sleep(for: .seconds(2))
+            sysExtnState = if !shouldFail {
+                .installed
+            } else {
+                .failed("Failed to install extension")
+            }
+        } catch {
+            sysExtnState = .failed("Installation was interrupted")
+        }
+    }
+
+    func disableExtension() async -> Bool {
+        // Simulate disabling with a delay
+        do {
+            try await Task.sleep(for: .seconds(1))
+        } catch {
+            return false
+        }
+
+        if !shouldFail {
+            neState = .disabled
+            state = .disabled
+            return true
+        } else {
+            neState = .failed("Failed to disable network extension")
+            return false
+        }
+    }
+
+    func enableExtension() async -> Bool {
+        // Simulate enabling with a delay
+        do {
+            try await Task.sleep(for: .seconds(1))
+        } catch {
+            return false
+        }
+
+        if !shouldFail {
+            neState = .enabled
+            state = .disabled // Just disabled, not connected yet
+            return true
+        } else {
+            neState = .failed("Failed to enable network extension")
+            return false
+        }
+    }
 }

Coder Desktop/Coder Desktop/State.swift

@@ -8,7 +8,7 @@ class AppState: ObservableObject {
     let appId = Bundle.main.bundleIdentifier!
 
     // Stored in UserDefaults
-    @Published private(set) var hasSession: Bool {
+    @Published var hasSession: Bool {
         didSet {
             guard persistent else { return }
             UserDefaults.standard.set(hasSession, forKey: Keys.hasSession)

Coder Desktop/Coder Desktop/SystemExtension.swift

@@ -81,6 +81,121 @@ extension CoderVPNService: SystemExtensionAsyncRecorder {
         OSSystemExtensionManager.shared.submitRequest(request)
         logger.info("submitted SystemExtension request with bundleID: \(bundleID)")
     }
+
+    func deregisterSystemExtension() async -> Bool {
+        logger.info("Starting network extension deregistration...")
+
+        // Extension bundle identifier - must match what's used in the app
+        let extensionBundleIdentifier = "com.coder.Coder-Desktop.VPN"
+
+        return await withCheckedContinuation { continuation in
+            // Create a task to handle the deregistration with timeout
+            let timeoutTask = Task {
+                // Set a timeout for the operation
+                let timeoutInterval: TimeInterval = 30.0 // 30 seconds
+
+                // Use a custom holder for the delegate to keep it alive
+                // and store the result from the callback
+                final class DelegateHolder {
+                    var delegate: DeregistrationDelegate?
+                    var result: Bool?
+                }
+
+                let holder = DelegateHolder()
+
+                // Create the delegate with a completion handler
+                let delegate = DeregistrationDelegate(completionHandler: { result in
+                    holder.result = result
+                })
+                holder.delegate = delegate
+
+                // Create and submit the deactivation request
+                let request = OSSystemExtensionRequest.deactivationRequest(
+                    forExtensionWithIdentifier: extensionBundleIdentifier,
+                    queue: .main
+                )
+                request.delegate = delegate
+
+                // Submit the request on the main thread
+                await MainActor.run {
+                    OSSystemExtensionManager.shared.submitRequest(request)
+                }
+
+                // Set up timeout using a separate task
+                let timeoutDate = Date().addingTimeInterval(timeoutInterval)
+
+                // Wait for completion or timeout
+                while holder.result == nil, Date() < timeoutDate {
+                    // Sleep a bit before checking again (100ms)
+                    try? await Task.sleep(nanoseconds: 100_000_000)
+
+                    // Check for cancellation
+                    if Task.isCancelled {
+                        break
+                    }
+                }
+
+                // Handle the result
+                if let result = holder.result {
+                    logger.info("System extension deregistration completed with result: \(result)")
+                    return result
+                } else {
+                    logger.error("System extension deregistration timed out after \(timeoutInterval) seconds")
+                    return false
+                }
+            }
+
+            // Use Task.detached to handle potential continuation issues
+            Task.detached {
+                let result = await timeoutTask.value
+                continuation.resume(returning: result)
+            }
+        }
+    }
+
+    // A dedicated delegate class for system extension deregistration
+    private class DeregistrationDelegate: NSObject, OSSystemExtensionRequestDelegate {
+        private var logger = Logger(subsystem: Bundle.main.bundleIdentifier!, category: "vpn-deregistrar")
+        private var completionHandler: (Bool) -> Void
+
+        init(completionHandler: @escaping (Bool) -> Void) {
+            self.completionHandler = completionHandler
+            super.init()
+        }
+
+        func request(_: OSSystemExtensionRequest, didFinishWithResult result: OSSystemExtensionRequest.Result) {
+            switch result {
+            case .completed:
+                logger.info("System extension was successfully deregistered")
+                completionHandler(true)
+            case .willCompleteAfterReboot:
+                logger.info("System extension will be deregistered after reboot")
+                completionHandler(true)
+            @unknown default:
+                logger.error("System extension deregistration completed with unknown result")
+                completionHandler(false)
+            }
+        }
+
+        func request(_: OSSystemExtensionRequest, didFailWithError error: Error) {
+            logger.error("System extension deregistration failed: \(error.localizedDescription)")
+            completionHandler(false)
+        }
+
+        func requestNeedsUserApproval(_: OSSystemExtensionRequest) {
+            logger.info("System extension deregistration needs user approval")
+            // We don't complete here, as we'll get another callback when approval is granted or denied
+        }
+
+        func request(
+            _: OSSystemExtensionRequest,
+            actionForReplacingExtension _: OSSystemExtensionProperties,
+            withExtension _: OSSystemExtensionProperties
+        ) -> OSSystemExtensionRequest.ReplacementAction {
+            logger.info("System extension replacement request")
+            return .replace
+        }
+    }
 }
 
 /// A delegate for the OSSystemExtensionRequest that maps the callbacks to async calls on the