small fixes

Author: FaserF

scripts/build_release.ps1

@@ -491,6 +491,22 @@ if ($Legacy -and $IsWinBuild) {
     }
 }
 
+# --- 7. CLEANUP / RESTORE SPLASH ---
+Write-Host "`nRestoring original Splash Screen..." -ForegroundColor Cyan
+try {
+    $SplashScript = Join-Path $RepoRoot "scripts/generate_splash.py"
+    if (Test-Path $SplashScript) {
+        if ($IsWinBuild) {
+            python $SplashScript --restore
+        }
+        else {
+            python3 $SplashScript --restore
+        }
+    }
+} catch {
+    Write-Warning "Failed to restore splash screen: $_"
+}
+
 # --- Capture Build End Time and Calculate Duration ---
 $BuildEndTime = Get-Date
 $BuildEndTimeString = $BuildEndTime.ToString("yyyy-MM-dd HH:mm:ss")

scripts/generate_splash.py

@@ -124,13 +124,42 @@ def generate_splash(version=None):
                 width=2
             )
 
+    # Backup original splash if it exists and backup doesn't
+    backup_path = output_path.with_suffix(".png.bak")
+    if output_path.exists() and not backup_path.exists():
+        import shutil
+        shutil.copy2(output_path, backup_path)
+        print(f"Backed up original splash to: {backup_path}")
+
     # Save
     img.save(output_path)
     print(f"Splash screen generated at: {output_path}")
 
+def restore_splash():
+    base_dir = Path(__file__).resolve().parent.parent
+    splash_path = base_dir / "src" / "switchcraft" / "assets" / "splash.png"
+    backup_path = splash_path.with_suffix(".png.bak")
+
+    if backup_path.exists():
+        import shutil
+        shutil.copy2(backup_path, splash_path)
+        print(f"Restored original splash from: {backup_path}")
+        # Optional: Delete backup? User might want to keep it safe.
+        # But if we want to ensure 'git status' is clean, we should keep the original 'splash.png'
+        # intact. The backup file is untracked usually.
+        # Let's remove the backup to keep folder clean.
+        os.remove(backup_path)
+        print("Removed backup file.")
+    else:
+        print("No backup found to restore.")
+
 if __name__ == "__main__":
     parser = argparse.ArgumentParser()
     parser.add_argument("--version", help="Version string to display", default=None)
+    parser.add_argument("--restore", help="Restore original splash screen", action="store_true")
     args = parser.parse_args()
 
-    generate_splash(args.version)
+    if args.restore:
+        restore_splash()
+    else:
+        generate_splash(args.version)

src/switchcraft/assets/splash.png

@@ -920,187 +920,118 @@ def _start_github_login(self, e):
         # Force update to show loading dialog
         self.app_page.update()
 
-        # Start device flow in background (network call)
-
-        def _init_flow():
+        # Start device flow in background (using run_task for async compatibility)
+        async def _run_login_flow():
             try:
-                flow = AuthService.initiate_device_flow()
-                if not flow:
-                    # Marshal UI updates to main thread
-                    # Capture original button state in closure using default parameter to avoid scope issues
-                    def _handle_no_flow(orig_text=original_text, orig_icon=original_icon):
-                        self._close_dialog(loading_dlg)
-                        self._show_snack("Login init failed", "RED")
-                        # Restore button state
-                        if hasattr(self, 'login_btn'):
-                            if hasattr(self.login_btn, 'text'):
-                                self.login_btn.text = orig_text
-                            else:
-                                self.login_btn.content = orig_text
-                            self.login_btn.icon = orig_icon
-                            if self.page:
-                                self.login_btn.update()
-                    self._run_task_with_fallback(_handle_no_flow, error_msg="Failed to initialize login flow")
-                    return None
-                return flow
-            except Exception as ex:
-                logger.exception(f"Error initiating device flow: {ex}")
-                # Marshal UI updates to main thread
-                error_msg = f"Failed to initiate login flow: {ex}"
-                # Capture error_msg and original button state in closure using default parameter to avoid scope issues
-                def _handle_error(msg=error_msg, orig_text=original_text, orig_icon=original_icon):
-                    self._close_dialog(loading_dlg)
-                    self._show_snack(f"Login error: {msg}", "RED")
-                    # Restore button state
-                    if hasattr(self, 'login_btn'):
-                        if hasattr(self.login_btn, 'text'):
-                            self.login_btn.text = orig_text
-                        else:
-                            self.login_btn.content = orig_text
-                        self.login_btn.icon = orig_icon
-                        if self.page:
-                            self.login_btn.update()
-                self._run_task_with_fallback(_handle_error, error_msg=error_msg)
-                return None
-
-        # Show dialog with flow data on main thread
-        def _show_dialog_with_flow(flow):
-            if not flow:
-                return
+                # 1. Init Flow (Network IO)
+                # We run this in a thread executor if it's synchronous, or directly if async
+                # AuthService.initiate_device_flow is likely sync (requests), so we wrap it
+                import asyncio
 
-            def copy_code(e):
-                try:
-                    import pyperclip
-                    pyperclip.copy(flow.get("user_code"))
-                except Exception as e:
-                    logger.debug(f"Failed to copy user code to clipboard: {e}")
-                self._launch_url(flow.get("verification_uri"))
+                logger.debug("Starting GitHub login flow (Async)...")
 
-            btn_copy = ft.TextButton("Copy & Open", on_click=copy_code)
-            btn_cancel = ft.TextButton("Cancel", on_click=lambda e: self._close_dialog(dlg))
+                # Helper to run sync blocking IO in a thread executor (safe for async loop)
+                flow = await asyncio.to_thread(AuthService.initiate_device_flow)
 
-            dlg = ft.AlertDialog(
-                title=ft.Text(i18n.get("github_login") or "GitHub Login"),
-                content=ft.Column([
-                    ft.Text(i18n.get("please_visit") or "Please visit:"),
-                    ft.Text(flow.get("verification_uri"), color="BLUE", selectable=True),
-                    ft.Text(i18n.get("and_enter_code") or "And enter code:"),
-                    ft.Text(flow.get("user_code"), size=24, weight=ft.FontWeight.BOLD, selectable=True),
-                ], height=150, scroll=ft.ScrollMode.AUTO),
-                actions=[btn_copy, btn_cancel]
-            )
+                if not flow:
+                    self._close_dialog(loading_dlg)
+                    self._show_snack("Login init failed", "RED")
+                    self._restore_login_button(original_text, original_icon)
+                    return
 
-            # Close loading dialog first
-            self._close_dialog(loading_dlg)
+                # 2. Show Dialog
+                def copy_code(e):
+                    try:
+                        import pyperclip
+                        pyperclip.copy(flow.get("user_code"))
+                    except Exception as e:
+                        logger.debug(f"Failed to copy user code: {e}")
+                    self._launch_url(flow.get("verification_uri"))
+
+                btn_copy = ft.TextButton("Copy & Open", on_click=copy_code)
+                # We need a way to cancel the polling loop
+                cancel_event = asyncio.Event()
+
+                def on_cancel(e):
+                    cancel_event.set()
+                    self._close_dialog(dlg)
+                    self._restore_login_button(original_text, original_icon)
+
+                btn_cancel = ft.TextButton("Cancel", on_click=on_cancel)
+
+                dlg = ft.AlertDialog(
+                    modal=True,
+                    title=ft.Text(i18n.get("github_login") or "GitHub Login"),
+                    content=ft.Column([
+                        ft.Text(i18n.get("please_visit") or "Please visit:"),
+                        ft.Text(flow.get("verification_uri"), color="BLUE", selectable=True),
+                        ft.Text(i18n.get("and_enter_code") or "And enter code:"),
+                        ft.Text(flow.get("user_code"), size=24, weight=ft.FontWeight.BOLD, selectable=True),
+                    ], height=150, scroll=ft.ScrollMode.AUTO),
+                    actions=[btn_copy, btn_cancel]
+                )
 
-            # Show dialog on main thread
-            logger.debug(f"Opening device flow dialog for code {flow.get('user_code')}")
-            logger.info("Showing GitHub login dialog...")
+                self._close_dialog(loading_dlg)
+                self._open_dialog_safe(dlg)
 
-            # Use safe opener instead of manual property setting
-            self._open_dialog_safe(dlg)
-            logger.debug("Device flow dialog opened")
+                # 3. Poll for Token (Async Loop)
+                device_code = flow.get("device_code")
+                interval = flow.get("interval", 5)
+                expires_in = flow.get("expires_in", 900)
+                start_time = asyncio.get_event_loop().time()
 
-            # Poll for token in background thread
-            def _poll_token():
-                try:
-                    token = AuthService.poll_for_token(flow.get("device_code"), flow.get("interval"), flow.get("expires_in"))
+                while not cancel_event.is_set():
+                    # Check timeout
+                    if asyncio.get_event_loop().time() - start_time > expires_in:
+                        self._close_dialog(dlg)
+                        self._show_snack("Login timed out", "RED")
+                        self._restore_login_button(original_text, original_icon)
+                        return
+
+                    # Poll
+                    # AuthService.poll_for_token is usually blocking with its own sleep,
+                    # but we want to control the sleep here for cancellation.
+                    # We'll use a modified poll check that strictly checks ONCE.
+                    # Use to_thread to keep UI responsive
+                    token = await asyncio.to_thread(AuthService.check_token_once, device_code)
 
-                    # Close dialog and show result on main thread
-                    async def _close_and_result():
+                    if token:
                         self._close_dialog(dlg)
-                        # Restore button state
-                        if hasattr(self, 'login_btn'):
-                            self.login_btn.text = original_text
-                            self.login_btn.icon = original_icon
-                            self.login_btn.update()
-                        if token:
-                            AuthService.save_token(token)
-                            self._update_sync_ui()
-                            self._show_snack(i18n.get("login_success") or "Login Successful!", "GREEN")
-                        else:
-                            self._show_snack(i18n.get("login_failed") or "Login Failed or Timed out", "RED")
+                        AuthService.save_token(token)
+                        self._update_sync_ui()
+                        self._show_snack(i18n.get("login_success") or "Login Successful!", "GREEN")
+                        self._restore_login_button(original_text, original_icon)
+                        return
 
-                    if hasattr(self.app_page, 'run_task'):
-                        self.app_page.run_task(_close_and_result)
-                    else:
-                        # Fallback: execute synchronously if run_task not available
-                        # Note: This is not ideal but provides backward compatibility
-                        import asyncio
-                        try:
-                            # In a background thread, there's no running loop, so go directly to asyncio.run
-                            asyncio.run(_close_and_result())
-                        except Exception as e:
-                            logger.warning(f"Failed to run async close_and_result: {e}", exc_info=True)
-                            # Last resort: try to execute the logic directly
-                            dlg.open = False
-                            self.app_page.update()
-                            if token:
-                                AuthService.save_token(token)
-                                self._update_sync_ui()
-                                self._show_snack(i18n.get("login_success") or "Login Successful!", "GREEN")
-                            else:
-                                self._show_snack(i18n.get("login_failed") or "Login Failed or Timed out", "RED")
-                except Exception as e:
-                    # Catch all exceptions including KeyboardInterrupt to prevent unhandled thread exceptions
-                    logger.exception(f"Unexpected error in token polling background thread: {e}")
+                    # Wait for interval
+                    try:
+                        await asyncio.wait_for(cancel_event.wait(), timeout=interval)
+                        if cancel_event.is_set():
+                            logger.info("Login cancelled by user")
+                            return
+                    except asyncio.TimeoutError:
+                        continue # Interval passed, poll again
 
-            threading.Thread(target=_poll_token, daemon=True).start()
+            except Exception as ex:
+                logger.exception(f"Error in GitHub Login Flow: {ex}")
+                self._close_dialog(loading_dlg)
+                # Ensure dlg is closed if open
+                if 'dlg' in locals():
+                    self._close_dialog(dlg)
 
-        # Start flow initiation in background, then show dialog on main thread
-        def _flow_complete():
-            flow = _init_flow()
-            if flow:
-                # Create a wrapper function that binds the flow argument
-                # This avoids lambda and ensures proper integration with run_task
-                def _show_dialog_wrapper():
-                    _show_dialog_with_flow(flow)
+                self._show_snack(f"Login Error: {ex}", "RED")
+                self._restore_login_button(original_text, original_icon)
 
-                def _fallback_show_dialog():
-                    try:
-                        _show_dialog_with_flow(flow)
-                    except Exception as ex2:
-                        logger.exception(f"Error showing dialog directly: {ex2}")
-                        loading_dlg.open = False
-                        self.app_page.update()
-                        raise  # Re-raise to trigger error handling in helper
-
-                # Use shared helper for run_task with fallback
-                self._run_task_with_fallback(
-                    _show_dialog_wrapper,
-                    fallback_func=_fallback_show_dialog,
-                    error_msg="Failed to show login dialog"
-                )
+        self._run_task_safe(_run_login_flow)
 
-        def _bg_wrapper():
-            try:
-                logger.debug("Starting GitHub login background task...")
-                _flow_complete()
-            except Exception as e:
-                 logger.exception(f"CRITICAL ERROR in GitHub Login background thread: {e}")
-                 # Ensure UI is restored even on critical thread crash
-                 def restore_ui():
-                     try:
-                        if hasattr(self, 'login_btn'):
-                            if hasattr(self.login_btn, 'text'):
-                                self.login_btn.text = original_text
-                            else:
-                                self.login_btn.content = original_text
-                            self.login_btn.icon = original_icon
-                            self.login_btn.update()
-                     except Exception as ex:
-                         logger.error(f"Failed to restore button state: {ex}")
-
-                     try:
-                        loading_dlg.open = False
-                        self.app_page.update()
-                     except Exception as ex:
-                        logger.error(f"Failed to close loading dialog: {ex}")
-
-                     self._show_snack(f"Critical Login Error: {e}", "RED")
-                 self._run_task_safe(restore_ui)
-
-        threading.Thread(target=_bg_wrapper, daemon=True).start()
+    def _restore_login_button(self, text, icon):
+        if hasattr(self, 'login_btn'):
+            if hasattr(self.login_btn, 'text'):
+                self.login_btn.text = text
+            else:
+                self.login_btn.content = text
+            self.login_btn.icon = icon
+            self.login_btn.update()
 
     def _logout_github(self, e):
         """

src/switchcraft/gui_modern/views/settings_view.py

@@ -45,6 +45,45 @@ def initiate_device_flow(cls) -> Optional[Dict[str, Any]]:
             logger.error(f"Failed to initiate device flow: {e}")
             return None
 
+    @classmethod
+    def check_token_once(cls, device_code: str) -> Optional[str]:
+        """
+        Performs a single check for the access token.
+        Returns token if successful, None otherwise.
+        Used by async loops that manage their own sleeping.
+        """
+        headers = {"Accept": "application/json"}
+        data = {
+            "client_id": cls.CLIENT_ID,
+            "device_code": device_code,
+            "grant_type": "urn:ietf:params:oauth:grant-type:device_code"
+        }
+
+        try:
+            response = requests.post(cls.TOKEN_URL, headers=headers, data=data, timeout=10)
+            response.raise_for_status()
+            resp_data = response.json()
+
+            if "access_token" in resp_data:
+                return resp_data["access_token"]
+
+            error = resp_data.get("error")
+            if error in ["authorization_pending", "slow_down"]:
+                return None
+            elif error == "expired_token":
+                logger.error("Device code expired.")
+                return None
+            elif error == "access_denied":
+                logger.error("User denied access.")
+                return None
+            else:
+                logger.debug(f"Polling error: {error}")
+                return None
+
+        except Exception as e:
+            logger.debug(f"Token check failed (network): {e}")
+            return None
+
     @classmethod
     def poll_for_token(cls, device_code: str, interval: int = 5, expires_in: int = 900) -> Optional[str]:
         """