fix: comprehensive permission error handling and UI improvements

- Enhanced directory creation with proper permissions (0o755)
- Added pre-conversion permission checks and test writes
- Improved error messages for permission issues
- Fixed File column to show output filename with new extension
- Added right-click context menu for Active Conversions table:
  * Play Media - opens converted file with default player
  * Open Output Folder - opens folder containing output file
- Added permission verification before FFmpeg execution
- Attempts to fix permissions automatically when possible
- Better handling of existing files during overwrite operations

Fixes permission denied errors when writing to output directory

Author: VoxHash

handforge/core/orchestrator.py

@@ -74,7 +74,17 @@ def run(self):
                 return
 
             # Build output path
-            dst = out_path(self.job.dst_dir, self.job.src, self.job.format)
+            try:
+                dst = out_path(self.job.dst_dir, self.job.src, self.job.format)
+            except PermissionError as e:
+                self.sig_done.emit(self.wid, False, f"Permission error: {str(e)}", "")
+                return
+            
+            # Verify output directory is writable before proceeding
+            output_dir = os.path.dirname(dst)
+            if not os.access(output_dir, os.W_OK):
+                self.sig_done.emit(self.wid, False, f"Output directory is not writable: {output_dir}. Please check permissions or choose a different output directory.", "")
+                return
 
             # Check if output exists
             if os.path.exists(dst):
@@ -88,6 +98,15 @@ def run(self):
                     while os.path.exists(dst):
                         dst = f"{base} ({counter}){ext}"
                         counter += 1
+                elif on_exists == "overwrite":
+                    # Try to make existing file writable if we're overwriting
+                    try:
+                        import stat
+                        current_mode = os.stat(dst).st_mode
+                        os.chmod(dst, current_mode | stat.S_IWUSR)
+                    except (PermissionError, OSError):
+                        # If we can't fix permissions, FFmpeg will fail with a clear error
+                        pass
 
             # For two-pass encoding, first pass outputs to null device
             first_pass_dst = dst
@@ -150,6 +169,22 @@ def run(self):
             # Run FFmpeg
             start_time = time.time()
 
+            # Verify we can write to the output location before starting FFmpeg
+            output_dir = os.path.dirname(dst)
+            try:
+                # Test write permission by trying to create a temporary file
+                import tempfile
+                test_file = os.path.join(output_dir, f".handforge_test_{os.getpid()}")
+                try:
+                    with open(test_file, 'w') as f:
+                        f.write('test')
+                    os.remove(test_file)
+                except (PermissionError, OSError) as e:
+                    self.sig_done.emit(self.wid, False, f"Cannot write to output directory '{output_dir}': {e}. Please check permissions or choose a different output directory.", "")
+                    return
+            except Exception as e:
+                self.sig_log.emit(self.wid, f"Warning: Could not verify write permissions: {e}")
+            
             # Log command details for debugging
             self.sig_log.emit(self.wid, f"Starting conversion: {os.path.basename(self.job.src)}")
             self.sig_log.emit(self.wid, f"Format: {self.job.format}, Mode: {self.job.mode}")

handforge/ui/main_window.py

@@ -281,6 +281,10 @@ def init_ui(self):
         # Connect cell clicked signal for View Log button
         self.workers_table.cellClicked.connect(self._on_workers_table_cell_clicked)
 
+        # Enable context menu for Active Conversions table
+        self.workers_table.setContextMenuPolicy(Qt.ContextMenuPolicy.CustomContextMenu)
+        self.workers_table.customContextMenuRequested.connect(self.show_workers_context_menu)
+        
         splitter.addWidget(workers_group)
         splitter.setSizes([450, 750])
 
@@ -900,6 +904,12 @@ def _on_worker_done(self, wid: int, success: bool, message: str, output_path: st
             self.workers_data[wid]["status"] = "Done" if success else "Failed"
             self.workers_data[wid]["message"] = message
             self.workers_data[wid]["output_path"] = output_path
+            # Update file name to show output filename with new extension
+            if output_path and os.path.exists(output_path):
+                self.workers_data[wid]["file"] = os.path.basename(output_path)
+            elif output_path:
+                # Even if file doesn't exist (failed), show intended output filename
+                self.workers_data[wid]["file"] = os.path.basename(output_path)
             self.update_workers_table()
 
             # Show notification with file location if successful
@@ -967,9 +977,11 @@ def _on_tray_activated(self, reason):
 
     def _on_worker_started(self, wid: int, file_path: str):
         """Handle worker started - initialize worker data with file name."""
+        # Store input file path for reference
         file_name = os.path.basename(file_path)
         self.workers_data[wid] = {
-                "file": file_name,
+                "file": file_name,  # Will be updated to output filename when conversion completes
+                "input_path": file_path,  # Store input path
                 "elapsed": 0,
                 "eta": 0,
                 "speed": "0.0x",
@@ -985,12 +997,15 @@ def _on_worker_progress(self, wid: int, progress: float, elapsed: float, eta: fl
         if wid not in self.workers_data:
             # Get file name from orchestrator if available
             file_name = ""
+            input_path = ""
             if wid in self.orchestrator.workers:
                 worker = self.orchestrator.workers[wid]
-                file_name = os.path.basename(worker.job.src)
+                input_path = worker.job.src
+                file_name = os.path.basename(input_path)
 
             self.workers_data[wid] = {
                 "file": file_name,
+                "input_path": input_path,
                 "elapsed": 0,
                 "eta": 0,
                 "speed": "",
@@ -1012,6 +1027,7 @@ def _on_worker_log(self, wid: int, log_line: str):
         if wid not in self.workers_data:
             self.workers_data[wid] = {
                 "file": "",
+                "input_path": "",
                 "elapsed": 0,
                 "eta": 0,
                 "speed": "",
@@ -1023,6 +1039,28 @@ def _on_worker_log(self, wid: int, log_line: str):
         self.workers_data[wid]["log"].append(log_line)
         if len(self.workers_data[wid]["log"]) > 100:
             self.workers_data[wid]["log"].pop(0)
+        
+        # Try to extract output path from log if available
+        if "Output:" in log_line and not self.workers_data[wid].get("output_path"):
+            try:
+                output_path = log_line.split("Output:", 1)[1].strip()
+                if output_path:
+                    self.workers_data[wid]["output_path"] = output_path
+                    # Update file name to output filename if file exists
+                    if os.path.exists(output_path):
+                        self.workers_data[wid]["file"] = os.path.basename(output_path)
+            except:
+                pass
+        
+        # Try to extract output path from log if available
+        if "Output:" in log_line and not self.workers_data[wid].get("output_path"):
+            try:
+                output_path = log_line.split("Output:", 1)[1].strip()
+                if output_path and os.path.exists(output_path):
+                    self.workers_data[wid]["output_path"] = output_path
+                    self.workers_data[wid]["file"] = os.path.basename(output_path)
+            except:
+                pass
 
     def update_workers_table(self):
         """Update the workers table."""
@@ -1380,6 +1418,86 @@ def remove_selected_from_queue(self):
         self.update_queue_table()
         self.update_queue_count()
 
+    def show_workers_context_menu(self, position):
+        """Show context menu for Active Conversions table."""
+        menu = QMenu(self)
+        
+        # Get selected rows
+        selected_rows = self.workers_table.selectionModel().selectedRows()
+        if not selected_rows:
+            menu.exec(self.workers_table.viewport().mapToGlobal(position))
+            return
+        
+        # Get the first selected row's worker data
+        row = selected_rows[0].row()
+        wid_item = self.workers_table.item(row, 0)
+        if not wid_item:
+            menu.exec(self.workers_table.viewport().mapToGlobal(position))
+            return
+        
+        wid = int(wid_item.text())
+        if wid not in self.workers_data:
+            menu.exec(self.workers_table.viewport().mapToGlobal(position))
+            return
+        
+        data = self.workers_data[wid]
+        output_path = data.get("output_path", "")
+        status = data.get("status", "")
+        
+        # Only show menu options for completed conversions with valid output
+        if status == "Done" and output_path and os.path.exists(output_path):
+            menu.addAction("▶️ Play Media", lambda: self.play_media(output_path))
+            menu.addSeparator()
+            menu.addAction("📁 Open Output Folder", lambda: self.open_output_folder(output_path))
+        elif output_path:
+            # Even if failed, allow opening the folder
+            menu.addAction("📁 Open Output Folder", lambda: self.open_output_folder(output_path))
+        else:
+            menu.addAction("No output file available")
+        
+        menu.exec(self.workers_table.viewport().mapToGlobal(position))
+    
+    def play_media(self, file_path: str):
+        """Open media file with default system player."""
+        import subprocess
+        import platform
+        
+        if not os.path.exists(file_path):
+            QMessageBox.warning(self, "File Not Found", f"The file does not exist:\n{file_path}")
+            return
+        
+        try:
+            system = platform.system()
+            if system == "Windows":
+                os.startfile(file_path)
+            elif system == "Darwin":  # macOS
+                subprocess.run(["open", file_path], check=True)
+            else:  # Linux and others
+                subprocess.run(["xdg-open", file_path], check=True)
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Failed to open media file:\n{str(e)}")
+    
+    def open_output_folder(self, file_path: str):
+        """Open the folder containing the output file."""
+        import subprocess
+        import platform
+        
+        folder_path = os.path.dirname(file_path)
+        if not os.path.exists(folder_path):
+            QMessageBox.warning(self, "Folder Not Found", f"The folder does not exist:\n{folder_path}")
+            return
+        
+        try:
+            system = platform.system()
+            if system == "Windows":
+                os.startfile(folder_path)
+            elif system == "Darwin":  # macOS
+                subprocess.run(["open", folder_path], check=True)
+            else:  # Linux and others
+                subprocess.run(["xdg-open", folder_path], check=True)
+        except Exception as e:
+            QMessageBox.critical(self, "Error", f"Failed to open folder:\n{str(e)}")
+    
     def clear_completed_workers(self):
         """Clear completed and failed workers from the Active Conversions table."""
         # Find workers that are done or failed

handforge/util/ffmpeg.py

@@ -810,8 +810,28 @@ def out_path(dst_dir: str, src: str, fmt: str) -> str:
     # Expand user directory
     dst_dir = os.path.expanduser(dst_dir)
 
-    # Create directory if it doesn't exist
-    os.makedirs(dst_dir, exist_ok=True)
+    # Create directory if it doesn't exist with proper permissions
+    try:
+        os.makedirs(dst_dir, mode=0o755, exist_ok=True)
+    except PermissionError:
+        # If permission denied, try with default mode
+        try:
+            os.makedirs(dst_dir, exist_ok=True)
+        except PermissionError as e:
+            raise PermissionError(f"Cannot create output directory '{dst_dir}': {e}. Please check permissions or choose a different output directory.")
+    
+    # Verify directory is writable
+    if not os.access(dst_dir, os.W_OK):
+        # Try to fix permissions if possible
+        try:
+            import stat
+            current_mode = os.stat(dst_dir).st_mode
+            # Add write permission for owner
+            os.chmod(dst_dir, current_mode | stat.S_IWUSR)
+            if not os.access(dst_dir, os.W_OK):
+                raise PermissionError(f"Output directory '{dst_dir}' is not writable. Please check permissions or choose a different output directory.")
+        except (PermissionError, OSError) as e:
+            raise PermissionError(f"Output directory '{dst_dir}' is not writable: {e}. Please check permissions or choose a different output directory.")
 
     # Get source filename without extension
     src_basename = os.path.basename(src)
@@ -853,4 +873,17 @@ def out_path(dst_dir: str, src: str, fmt: str) -> str:
     }
 
     ext = ext_map.get(fmt.lower(), f".{fmt}")
-    return os.path.join(dst_dir, f"{src_name}{ext}")
+    output_file = os.path.join(dst_dir, f"{src_name}{ext}")
+    
+    # Check if output file exists and has wrong permissions
+    if os.path.exists(output_file):
+        try:
+            # Try to make file writable if it exists
+            import stat
+            current_mode = os.stat(output_file).st_mode
+            os.chmod(output_file, current_mode | stat.S_IWUSR)
+        except (PermissionError, OSError):
+            # If we can't fix permissions, that's okay - FFmpeg will handle overwrite
+            pass
+    
+    return output_file