Sync from development - prepare for v0.4.0

jackify/frontends/gui/screens/install_ttw_thread.py

@@ -0,0 +1,151 @@
+"""TTW installation worker thread."""
+from PySide6.QtCore import QThread, Signal
+import time
+
+from ..utils import strip_ansi_control_codes
+
+
+class TTWInstallationThread(QThread):
+    output_batch_received = Signal(list)
+    progress_received = Signal(str)
+    installation_finished = Signal(bool, str)
+
+    def __init__(self, mpi_path, install_dir):
+        super().__init__()
+        self.mpi_path = mpi_path
+        self.install_dir = install_dir
+        self.cancelled = False
+        self.proc = None
+        self.output_buffer = []
+        self.last_emit_time = 0
+
+    def cancel(self):
+        self.cancelled = True
+        try:
+            if self.proc and self.proc.poll() is None:
+                self.proc.terminate()
+        except Exception:
+            pass
+
+    def process_and_buffer_line(self, raw_line):
+        """Clean one output line and queue it for batched emit."""
+        cleaned = strip_ansi_control_codes(raw_line).strip()
+
+        filtered_chars = []
+        for char in cleaned:
+            code = ord(char)
+            is_emoji = (
+                (0x1F300 <= code <= 0x1F9FF) or
+                (0x1F600 <= code <= 0x1F64F) or
+                (0x2600 <= code <= 0x26FF) or
+                (0x2700 <= code <= 0x27BF)
+            )
+            if not is_emoji:
+                filtered_chars.append(char)
+        cleaned = ''.join(filtered_chars).strip()
+
+        if cleaned:
+            self.output_buffer.append(cleaned)
+
+    def flush_output_buffer(self):
+        """Emit buffered lines as a batch."""
+        if self.output_buffer:
+            self.output_batch_received.emit(self.output_buffer[:])
+            self.output_buffer.clear()
+            self.last_emit_time = time.time()
+
+    def run(self):
+        try:
+            from jackify.backend.handlers.ttw_installer_handler import TTWInstallerHandler
+            from jackify.backend.handlers.filesystem_handler import FileSystemHandler
+            from jackify.backend.handlers.config_handler import ConfigHandler
+            from pathlib import Path
+            import tempfile
+
+            self.process_and_buffer_line("Initializing TTW installation...")
+            self.flush_output_buffer()
+
+            filesystem_handler = FileSystemHandler()
+            config_handler = ConfigHandler()
+            ttw_handler = TTWInstallerHandler(
+                steamdeck=False,
+                verbose=False,
+                filesystem_handler=filesystem_handler,
+                config_handler=config_handler,
+            )
+
+            output_file = tempfile.NamedTemporaryFile(
+                mode='w+', delete=False, suffix='.ttw_output', encoding='utf-8'
+            )
+            output_file_path = Path(output_file.name)
+            output_file.close()
+
+            self.process_and_buffer_line("Starting TTW installation...")
+            self.flush_output_buffer()
+
+            self.proc, error_msg = ttw_handler.start_ttw_installation(
+                Path(self.mpi_path),
+                Path(self.install_dir),
+                output_file_path,
+            )
+
+            if not self.proc:
+                self.installation_finished.emit(False, error_msg or "Failed to start TTW installation")
+                return
+
+            self.process_and_buffer_line("TTW_Linux_Installer process started, monitoring output...")
+            self.flush_output_buffer()
+
+            last_position = 0
+            BATCH_INTERVAL = 0.3
+
+            while self.proc.poll() is None:
+                if self.cancelled:
+                    break
+
+                try:
+                    with open(output_file_path, 'r', encoding='utf-8', errors='replace') as f:
+                        f.seek(last_position)
+                        new_lines = f.readlines()
+                        last_position = f.tell()
+
+                        for line in new_lines:
+                            if self.cancelled:
+                                break
+                            self.process_and_buffer_line(line.rstrip())
+
+                        if time.time() - self.last_emit_time >= BATCH_INTERVAL:
+                            self.flush_output_buffer()
+                except Exception:
+                    pass
+
+                time.sleep(0.1)
+
+            try:
+                with open(output_file_path, 'r', encoding='utf-8', errors='replace') as f:
+                    f.seek(last_position)
+                    for line in f.readlines():
+                        self.process_and_buffer_line(line.rstrip())
+                self.flush_output_buffer()
+            except Exception:
+                pass
+
+            try:
+                output_file_path.unlink(missing_ok=True)
+            except Exception:
+                pass
+
+            ttw_handler.cleanup_ttw_process(self.proc)
+
+            returncode = self.proc.returncode if self.proc else -1
+            if self.cancelled:
+                self.installation_finished.emit(False, "Installation cancelled by user")
+            elif returncode == 0:
+                self.installation_finished.emit(True, "TTW installation completed successfully!")
+            else:
+                self.installation_finished.emit(False, f"TTW installation failed with exit code {returncode}")
+
+        except Exception as e:
+            import traceback
+            traceback.print_exc()
+            self.installation_finished.emit(False, f"Installation error: {str(e)}")