Rsdvops copilot (#2)

* Commit to rsdvops_copilot

* Pre-release 0.32.110

* Pre-release 0.32.111

* Pre-release 0.32.112

* Release 0.33.0

---------

Co-authored-by: GitHub Actions <actions@github.com>

Author: rainbowbeast0

.github/actions/set-xcode-version/action.yml

@@ -6,7 +6,7 @@ inputs:
       Xcode version to use, in semver(ish)-style matching the format on the Actions runner image.
       See available versions at https://github.com/actions/runner-images/blame/main/images/macos/macos-14-Readme.md#xcode
     required: false
-    default: '15.3'
+    default: '16.2'
 outputs:
   xcode-path:
     description: "Path to current Xcode version"

CHANGELOG.md

@@ -5,6 +5,20 @@ All notable changes to this project will be documented in this file.
 The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
 and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
 
+## 0.33.0 - April 17, 2025
+### Added
+- Added support for new models in Chat: Claude 3.7 Sonnet and GPT 4.5
+- Implemented @workspace context feature allowing questions about the entire codebase in Copilot Chat
+
+### Changed
+- Simplified access to Copilot Chat from the Copilot for Xcode app with a single click
+- Enhanced instructions for granting background permissions
+
+### Fixed
+- Resolved false alarms for sign-in and free plan limit notifications
+- Improved app launch performance
+- Fixed workspace and context update issues
+
 ## 0.32.0 - March 11, 2025 (General Availability)
 ### Added
 - Implemented model picker for selecting LLM model in chat

CommunicationBridge/ServiceDelegate.swift

@@ -136,28 +136,100 @@ actor ExtensionServiceLauncher {
         isLaunching = true
 
         Logger.communicationBridge.info("Launching extension service app.")
-
-        NSWorkspace.shared.openApplication(
-            at: appURL,
-            configuration: {
-                let configuration = NSWorkspace.OpenConfiguration()
-                configuration.createsNewApplicationInstance = false
-                configuration.addsToRecentItems = false
-                configuration.activates = false
-                return configuration
-            }()
-        ) { app, error in
-            if let error = error {
-                Logger.communicationBridge.error(
-                    "Failed to launch extension service app: \(error)"
-                )
-            } else {
-                Logger.communicationBridge.info(
-                    "Finished launching extension service app."
-                )
+        
+        // First check if the app is already running
+        if let runningApp = NSWorkspace.shared.runningApplications.first(where: { 
+            $0.bundleIdentifier == appIdentifier 
+        }) {
+            Logger.communicationBridge.info("Extension service app already running with PID: \(runningApp.processIdentifier)")
+            self.application = runningApp
+            self.isLaunching = false
+            return
+        }
+        
+        // Implement a retry mechanism with exponential backoff
+        Task {
+            var retryCount = 0
+            let maxRetries = 3
+            var success = false
+            
+            while !success && retryCount < maxRetries {
+                do {
+                    // Add a delay between retries with exponential backoff
+                    if retryCount > 0 {
+                        let delaySeconds = pow(2.0, Double(retryCount - 1)) 
+                        Logger.communicationBridge.info("Retrying launch after \(delaySeconds) seconds (attempt \(retryCount + 1) of \(maxRetries))")
+                        try await Task.sleep(nanoseconds: UInt64(delaySeconds * 1_000_000_000))
+                    }
+                    
+                    // Use a task-based approach for launching with timeout
+                    let launchTask = Task<NSRunningApplication?, Error> { () -> NSRunningApplication? in
+                        return await withCheckedContinuation { continuation in
+                            NSWorkspace.shared.openApplication(
+                                at: appURL,
+                                configuration: {
+                                    let configuration = NSWorkspace.OpenConfiguration()
+                                    configuration.createsNewApplicationInstance = false
+                                    configuration.addsToRecentItems = false
+                                    configuration.activates = false
+                                    return configuration
+                                }()
+                            ) { app, error in
+                                if let error = error {
+                                    continuation.resume(returning: nil)
+                                } else {
+                                    continuation.resume(returning: app)
+                                }
+                            }
+                        }
+                    }
+                    
+                    // Set a timeout for the launch operation
+                    let timeoutTask = Task {
+                        try await Task.sleep(nanoseconds: 10_000_000_000) // 10 seconds
+                        return
+                    }
+                    
+                    // Wait for either the launch or the timeout
+                    let app = try await withTaskCancellationHandler {
+                        try await launchTask.value ?? nil
+                    } onCancel: {
+                        launchTask.cancel()
+                    }
+                    
+                    // Cancel the timeout task
+                    timeoutTask.cancel()
+                    
+                    if let app = app {
+                        // Success!
+                        self.application = app
+                        success = true
+                        break
+                    } else {
+                        // App is nil, retry
+                        retryCount += 1
+                        Logger.communicationBridge.info("Launch attempt \(retryCount) failed, app is nil")
+                    }
+                } catch {
+                    retryCount += 1
+                    Logger.communicationBridge.error("Error during launch attempt \(retryCount): \(error.localizedDescription)")
+                }
             }
-
-            self.application = app
+            
+            // Double-check we have a valid application
+            if !success && self.application == nil {
+                // After all retries, check once more if the app is running (it might have launched but we missed the callback)
+                if let runningApp = NSWorkspace.shared.runningApplications.first(where: { 
+                    $0.bundleIdentifier == appIdentifier 
+                }) {
+                    Logger.communicationBridge.info("Found running extension service after retries: \(runningApp.processIdentifier)")
+                    self.application = runningApp
+                    success = true
+                } else {
+                    Logger.communicationBridge.info("Failed to launch extension service after \(maxRetries) attempts")
+                }
+            }
+            
             self.isLaunching = false
         }
     }

Copilot for Xcode/App.swift

@@ -1,18 +1,145 @@
+import SwiftUI
 import Client
 import HostApp
 import LaunchAgentManager
 import SharedUIComponents
-import SwiftUI
 import UpdateChecker
 import XPCShared
+import HostAppActivator
 
 struct VisualEffect: NSViewRepresentable {
   func makeNSView(context: Self.Context) -> NSView { return NSVisualEffectView() }
   func updateNSView(_ nsView: NSView, context: Context) { }
 }
 
 class AppDelegate: NSObject, NSApplicationDelegate {
-    func applicationShouldTerminateAfterLastWindowClosed(_: NSApplication) -> Bool { true }
+    private var permissionAlertShown = false
+    
+    // Launch modes supported by the app
+    enum LaunchMode {
+        case chat
+        case settings
+    }
+    
+    func applicationDidFinishLaunching(_ notification: Notification) {
+        if #available(macOS 13.0, *) {
+            checkBackgroundPermissions()
+        }
+        
+        let launchMode = determineLaunchMode()
+        handleLaunchMode(launchMode)
+    }
+
+    func applicationShouldHandleReopen(_ sender: NSApplication, hasVisibleWindows flag: Bool) -> Bool {
+        if #available(macOS 13.0, *) {
+            checkBackgroundPermissions()
+        }
+        
+        let launchMode = determineLaunchMode()
+        handleLaunchMode(launchMode)
+        return true
+    }
+    
+    // MARK: - Helper Methods
+    
+    private func determineLaunchMode() -> LaunchMode {
+        let launchArgs = CommandLine.arguments
+        if launchArgs.contains("--settings") {
+            return .settings
+        } else {
+            return .chat
+        }
+    }
+    
+    private func handleLaunchMode(_ mode: LaunchMode) {
+        switch mode {
+        case .settings:
+            openSettings()
+        case .chat:
+            openChat()
+        }
+    }
+    
+    private func openSettings() {
+        DispatchQueue.main.async {
+            NSApp.activate(ignoringOtherApps: true)
+            if #available(macOS 14.0, *) {
+                let environment = SettingsEnvironment()
+                environment.open()
+            } else if #available(macOS 13.0, *) {
+                NSApp.sendAction(Selector(("showSettingsWindow:")), to: nil, from: nil)
+            } else {
+                NSApp.sendAction(Selector(("showPreferencesWindow:")), to: nil, from: nil)
+            }
+        }
+    }
+    
+    private func openChat() {
+        DispatchQueue.main.asyncAfter(deadline: .now() + 0.5) {
+            Task {
+                let service = try? getService()
+                try? await service?.openChat()
+            }
+        }
+    }
+    
+    @available(macOS 13.0, *)
+    private func checkBackgroundPermissions() {
+        Task {
+            // Direct check of permission status
+            let launchAgentManager = LaunchAgentManager()
+            let isPermissionGranted = await launchAgentManager.isBackgroundPermissionGranted()
+            
+            if !isPermissionGranted {
+                // Only show alert if permission isn't granted
+                DispatchQueue.main.async {
+                    if !self.permissionAlertShown {
+                        showBackgroundPermissionAlert()
+                        self.permissionAlertShown = true
+                    }
+                }
+            } else {
+                // Permission is granted, reset flag
+                self.permissionAlertShown = false
+            }
+        }
+    }
+    
+    // MARK: - Application Termination
+    
+    func applicationShouldTerminate(_ sender: NSApplication) -> NSApplication.TerminateReply {
+        // Immediately terminate extension service if it's running
+        if let extensionService = NSWorkspace.shared.runningApplications.first(where: {
+            $0.bundleIdentifier == "\(Bundle.main.bundleIdentifier!).ExtensionService"
+        }) {
+            extensionService.terminate()
+        }
+        
+        // Start cleanup in background without waiting
+        Task {
+            let quitTask = Task {
+                let service = try? getService()
+                try? await service?.quitService()
+            }
+            
+            // Wait just a tiny bit to allow cleanup to start
+            try? await Task.sleep(nanoseconds: 100_000_000) // 100ms
+            
+            DispatchQueue.main.async {
+                NSApp.reply(toApplicationShouldTerminate: true)
+            }
+        }
+        
+        return .terminateLater
+    }
+    
+    func applicationWillTerminate(_ notification: Notification) {        
+        if let extensionService = NSWorkspace.shared.runningApplications.first(where: {
+            $0.bundleIdentifier == "\(Bundle.main.bundleIdentifier!).ExtensionService"
+        }) {
+            extensionService.terminate()
+        }
+    }
 }
 
 class AppUpdateCheckerDelegate: UpdateCheckerDelegate {
@@ -28,16 +155,40 @@ class AppUpdateCheckerDelegate: UpdateCheckerDelegate {
 @main
 struct CopilotForXcodeApp: App {
     @NSApplicationDelegateAdaptor private var appDelegate: AppDelegate
+    
+    init() {
+        UserDefaults.setupDefaultSettings()
+        
+        Task {
+            await hostAppStore
+                .send(.general(.setupLaunchAgentIfNeeded))
+                .finish()
+        }
+        
+        DistributedNotificationCenter.default().addObserver(
+            forName: .openSettingsWindowRequest,
+            object: nil,
+            queue: .main
+        ) { _ in
+            DispatchQueue.main.async {
+                NSApp.activate(ignoringOtherApps: true)
+                if #available(macOS 14.0, *) {
+                    let environment = SettingsEnvironment()
+                    environment.open()
+                } else if #available(macOS 13.0, *) {
+                    NSApp.sendAction(Selector(("showSettingsWindow:")), to: nil, from: nil)
+                } else {
+                    NSApp.sendAction(Selector(("showPreferencesWindow:")), to: nil, from: nil)
+                }
+            }
+        }
+    }
 
     var body: some Scene {
-        WindowGroup {
+        Settings {
             TabContainer()
                 .frame(minWidth: 800, minHeight: 600)
                 .background(VisualEffect().ignoresSafeArea())
-                .onAppear {
-                    UserDefaults.setupDefaultSettings()
-                }
-                .copilotIntroSheet()
                 .environment(\.updateChecker, UpdateChecker(
                     hostBundle: Bundle.main,
                     checkerDelegate: AppUpdateCheckerDelegate()

Copilot for Xcode/Assets.xcassets/ChatIcon.imageset/Chat.svg

@@ -1,12 +1,15 @@
 {
   "images" : [
     {
-      "filename" : "Chat.svg",
+      "filename" : "ChatIcon.svg",
       "idiom" : "universal"
     }
   ],
   "info" : {
     "author" : "xcode",
     "version" : 1
+  },
+  "properties" : {
+    "preserves-vector-representation" : true
   }
 }