fix(core): unify IO error handling and improve cross-device move reliability

- Implemented standard _handle_gio_error across all FileOperationRunnables.
- Added explicit handling for cross-mount moves (WOULD_RECURSE) in TransferRunnable.
- Optimized signal forwarding in FileOperations to reduce redundant handlers.
- Consolidated bookmark management by removing legacy bookmarks.py bridge.
- Enhanced FileJob with status tracking for better lifecycle auditing.

Author: dragon-Elec

core/file_operations.py

@@ -6,7 +6,7 @@
 from PySide6.QtCore import QObject, Signal, Slot, QThreadPool, QMutex, QMutexLocker, Qt
 
 from core.file_workers import (
-    FileJob, FileOperationSignals, _make_gfile, _gfile_path,
+    FileJob, FileOperationSignals, _make_gfile, _gfile_path, _split_name_ext,
     TransferRunnable, RenameRunnable, CreateFolderRunnable,
     CreateFileRunnable, CreateSymlinkRunnable,
     generate_candidate_path,
@@ -18,15 +18,6 @@
 
 _MAX_RENAME_ATTEMPTS = 1000
 
-def _split_name_ext(filename: str) -> tuple[str, str]:
-    """Split filename into (base, ext). Handles .tar.gz and dotfiles."""
-    if filename.endswith(".tar.gz"):
-        return filename[:-7], ".tar.gz"
-    dot = filename.rfind(".")
-    if dot <= 0:
-        return filename, ""
-    return filename[:dot], filename[dot:]
-
 class FileOperations(QObject):
     """Central controller for non-blocking file I/O via QThreadPool."""
 
@@ -52,27 +43,18 @@ def __init__(self, parent=None):
 
         # Internal Signal Hub
         self._signals = FileOperationSignals()
-        self._signals.started.connect(self._on_started)
-        self._signals.progress.connect(self._on_progress)
+        self._signals.started.connect(self.operationStarted)
+        self._signals.progress.connect(self.operationProgress)
         self._signals.finished.connect(self._on_finished)
         self._signals.operationError.connect(self._on_error)
 
         # Trash Specific Internal Signals
         self._signals.itemListed.connect(self.itemListed)
         self._signals.trashNotSupported.connect(self.trashNotSupported)
-        
-    def setUndoManager(self, undo_manager):
-        self._undo_manager = undo_manager
 
     # -------------------------------------------------------------------------
     # SIGNAL HANDLERS
     # -------------------------------------------------------------------------
-    def _on_started(self, job_id: str, op_type: str, path: str):
-        self.operationStarted.emit(job_id, op_type, path)
-    
-    def _on_progress(self, job_id: str, current: int, total: int):
-        self.operationProgress.emit(job_id, current, total)
-    
     def _on_finished(self, tid: str, job_id: str, op_type: str, result_path: str, success: bool, message: str):
         with QMutexLocker(self._mutex):
             if job_id in self._jobs:

core/file_workers.py

@@ -71,10 +71,11 @@ class FileJob:
     dest: str = ""            # Destination path (or new name for rename)
     transaction_id: str = ""  # Links this job to a larger transaction (batch)
     cancellable: Gio.Cancellable = field(default_factory=Gio.Cancellable)
-    auto_rename: bool = False # [NEW] If True, automatically find a free name (For New Folder / Duplicate)
+    auto_rename: bool = False # If True, automatically find a free name (For New Folder / Duplicate)
     skipped_files: List[str] = field(default_factory=list) # For partial success
     overwrite: bool = False   # If True, overwrite existing files without prompt
     rename_to: str = ""       # Specific for Restore: if set, restore with this filename
+    status: str = "pending"   # Lifecycle: pending → running → done/error/cancelled
 
 class FileOperationSignals(QObject):
     """
@@ -131,6 +132,25 @@ def _progress_callback(self, current_bytes, total_bytes, user_data):
         """Gio progress callback adapter."""
         self.emit_progress(current_bytes, total_bytes)
 
+    def _handle_gio_error(self, e: GLib.Error, op_type: str, path: str, conflict_data=None):
+        """
+        Shared GIO error handler. Covers EXISTS (conflict), CANCELLED (silent),
+        and all other errors. Always calls emit_finished(False, ...).
+        """
+        if e.code == Gio.IOErrorEnum.EXISTS:
+            if conflict_data is None:
+                conflict_data = build_conflict_payload(path, path)
+            self.signals.operationError.emit(
+                self.job.transaction_id, self.job.id,
+                op_type, path, str(e), conflict_data
+            )
+        elif e.code != Gio.IOErrorEnum.CANCELLED:
+            self.signals.operationError.emit(
+                self.job.transaction_id, self.job.id,
+                op_type, path, str(e), None
+            )
+        self.emit_finished(False, str(e))
+
     def _run_create_operation(self, op_type: str, target_path: str):
         """
         Shared logic for all create operations (folder, file, symlink).
@@ -151,12 +171,7 @@ def _run_create_operation(self, op_type: str, target_path: str):
                     if e.code == Gio.IOErrorEnum.EXISTS:
                         counter += 1
                         continue
-                    if e.code != Gio.IOErrorEnum.CANCELLED:
-                        self.signals.operationError.emit(
-                            self.job.transaction_id, self.job.id,
-                            op_type, candidate, str(e), None
-                        )
-                    self.emit_finished(False, str(e))
+                    self._handle_gio_error(e, op_type, candidate)
                     return
             self.emit_finished(False, "Auto-rename limit reached")
             return
@@ -167,27 +182,12 @@ def _run_create_operation(self, op_type: str, target_path: str):
             self._do_create(gfile)
             self.emit_finished(True, target_path)
         except GLib.Error as e:
-            if e.code == Gio.IOErrorEnum.EXISTS:
-                conflict_data = build_conflict_payload(target_path, target_path)
-                self.signals.operationError.emit(
-                    self.job.transaction_id, self.job.id,
-                    op_type, target_path, str(e), conflict_data
-                )
-                self.emit_finished(False, str(e))
-            else:
-                if e.code != Gio.IOErrorEnum.CANCELLED:
-                    self.signals.operationError.emit(
-                        self.job.transaction_id, self.job.id,
-                        op_type, target_path, str(e), None
-                    )
-                self.emit_finished(False, str(e))
+            self._handle_gio_error(e, op_type, target_path)
 
     def _do_create(self, gfile):
         """Override in subclass. Execute the actual Gio create call."""
         raise NotImplementedError
 
-    # Removed local build_conflict_data helper, using global build_conflict_payload
-
 def _split_name_ext(filename: str) -> tuple[str, str]:
     """Split filename into (base, ext). Handles .tar.gz and dotfiles."""
     if filename.endswith(".tar.gz"):
@@ -260,7 +260,8 @@ def run(self):
                         self.emit_finished(True, "Success", result_override=final_dest)
                         return
                     except GLib.Error as e:
-                        # If it's a cross-device move, or directory merge, handle manually
+                        # Cross-device move or directory merge: handle manually.
+                        # 29 = G_IO_ERROR_WOULD_RECURSE (not always exposed in Python bindings)
                         if e.code in [Gio.IOErrorEnum.NOT_SUPPORTED, Gio.IOErrorEnum.WOULD_MERGE, 29]:
                             # Cross-device move or merge -> Recursive copy + delete
                             # Note: Recursive transfer logic handles its own errors, we need to catch EXISTS there too?
@@ -302,13 +303,10 @@ def run(self):
                     else:
                         # Conflict!
                         conflict_data = build_conflict_payload(self.job.source, final_dest)
-                        self.signals.operationError.emit(self.job.transaction_id, self.job.id, self.job.op_type, final_dest, str(e), conflict_data)
-                        self.emit_finished(False, str(e))
+                        self._handle_gio_error(e, self.job.op_type, final_dest, conflict_data)
                         return
                 else:
-                    if e.code != Gio.IOErrorEnum.CANCELLED:
-                        self.signals.operationError.emit(self.job.transaction_id, self.job.id, self.job.op_type, final_dest, str(e), None)
-                    self.emit_finished(False, str(e))
+                    self._handle_gio_error(e, self.job.op_type, final_dest)
                     return
 
         # If loop finishes without return (counter maxed)
@@ -348,7 +346,7 @@ def _recursive_transfer(self, source, dest, is_move=False):
             if is_move and not local_error:
                 try:
                     source.delete(self.job.cancellable)
-                except:
+                except Exception:
                     pass
         else:
             # File Transfer
@@ -367,22 +365,17 @@ def run(self):
             # dest holds the new NAME, not full path
             result = gfile.set_display_name(self.job.dest, self.job.cancellable)
             if result:
-                # Use the Gio.File returned by set_display_name for the correct path
                 abs_path = _gfile_path(result)
                 self.emit_finished(True, "Success", result_override=abs_path)
             else:
-                self.emit_finished(False, str(e))
+                self.emit_finished(False, "Rename returned no result")
         except GLib.Error as e:
             if e.code == Gio.IOErrorEnum.EXISTS:
-                 src_gfile = _make_gfile(self.job.source)
-                 dest_path = _gfile_path(src_gfile.get_parent().get_child(self.job.dest))
+                 dest_path = _gfile_path(gfile.get_parent().get_child(self.job.dest))
                  conflict_data = build_conflict_payload(self.job.source, dest_path)
-                 self.signals.operationError.emit(self.job.transaction_id, self.job.id, "rename", dest_path, str(e), conflict_data)
-                 self.emit_finished(False, str(e))
+                 self._handle_gio_error(e, "rename", dest_path, conflict_data)
             else:
-                 if e.code != Gio.IOErrorEnum.CANCELLED:
-                     self.signals.operationError.emit(self.job.transaction_id, self.job.id, "rename", self.job.source, str(e), None)
-                 self.emit_finished(False, str(e))
+                 self._handle_gio_error(e, "rename", self.job.source)
 
 class CreateFolderRunnable(FileOperationRunnable):
     """Creates a new directory."""