claude-mpm 3.3.0__py3-none-any.whl → 3.4.0__py3-none-any.whl

claude_mpm/services/socketio_server.py

@@ -21,17 +21,14 @@ try:
     import aiohttp
     from aiohttp import web
     SOCKETIO_AVAILABLE = True
-    try:
-        version = getattr(socketio, '__version__', 'unknown')
-        print(f"Socket.IO server using python-socketio v{version}")
-    except:
-        print("Socket.IO server using python-socketio (version unavailable)")
+    # Don't print at module level - this causes output during imports
+    # Version will be logged when server is actually started
 except ImportError:
     SOCKETIO_AVAILABLE = False
     socketio = None
     aiohttp = None
     web = None
-    print("WARNING: python-socketio or aiohttp package not available")
+    # Don't print warnings at module level
 
 from ..core.logger import get_logger
 from ..deployment_paths import get_project_root, get_scripts_dir
@@ -53,6 +50,7 @@ class SocketIOClientProxy:
         self.running = True  # Always "running" for compatibility
         self._sio_client = None
         self._client_thread = None
+        self._client_loop = None
         
     def start(self):
         """Start the Socket.IO client connection to the persistent server."""
@@ -69,12 +67,14 @@ class SocketIOClientProxy:
     def _start_client(self):
         """Start Socket.IO client in a background thread."""
         def run_client():
-            loop = asyncio.new_event_loop()
-            asyncio.set_event_loop(loop)
+            self._client_loop = asyncio.new_event_loop()
+            asyncio.set_event_loop(self._client_loop)
             try:
-                loop.run_until_complete(self._connect_and_run())
+                self._client_loop.run_until_complete(self._connect_and_run())
             except Exception as e:
                 self.logger.error(f"SocketIOClientProxy client thread error: {e}")
+            finally:
+                self._client_loop.close()
             
         self._client_thread = threading.Thread(target=run_client, daemon=True)
         self._client_thread.start()
@@ -123,10 +123,19 @@ class SocketIOClientProxy:
                     "data": data
                 }
                 
-                # Send asynchronously using emit
-                asyncio.create_task(
-                    self._sio_client.emit('claude_event', event)
-                )
+                # Send event safely using run_coroutine_threadsafe
+                if hasattr(self, '_client_loop') and self._client_loop and not self._client_loop.is_closed():
+                    try:
+                        future = asyncio.run_coroutine_threadsafe(
+                            self._sio_client.emit('claude_event', event),
+                            self._client_loop
+                        )
+                        # Don't wait for the result to avoid blocking
+                        self.logger.debug(f"SocketIOClientProxy: Scheduled emit for {event_type}")
+                    except Exception as e:
+                        self.logger.error(f"SocketIOClientProxy: Failed to schedule emit for {event_type}: {e}")
+                else:
+                    self.logger.warning(f"SocketIOClientProxy: Client event loop not available for {event_type}")
                 
                 self.logger.debug(f"SocketIOClientProxy: Sent event {event_type}")
             except Exception as e:
@@ -181,6 +190,13 @@ class SocketIOServer:
         
         if not SOCKETIO_AVAILABLE:
             self.logger.warning("Socket.IO support not available. Install 'python-socketio' and 'aiohttp' packages to enable.")
+        else:
+            # Log version info when server is actually created
+            try:
+                version = getattr(socketio, '__version__', 'unknown')
+                self.logger.info(f"Socket.IO server using python-socketio v{version}")
+            except:
+                self.logger.info("Socket.IO server using python-socketio (version unavailable)")
         
     def start(self):
         """Start the Socket.IO server in a background thread."""
@@ -254,10 +270,24 @@ class SocketIOServer:
             self.app = web.Application()
             self.sio.attach(self.app)
             
+            # Add CORS middleware
+            import aiohttp_cors
+            cors = aiohttp_cors.setup(self.app, defaults={
+                "*": aiohttp_cors.ResourceOptions(
+                    allow_credentials=True,
+                    expose_headers="*",
+                    allow_headers="*",
+                    allow_methods="*"
+                )
+            })
+            
             # Add HTTP routes
             self.app.router.add_get('/health', self._handle_health)
             self.app.router.add_get('/status', self._handle_health)
             self.app.router.add_get('/api/git-diff', self._handle_git_diff)
+            self.app.router.add_options('/api/git-diff', self._handle_cors_preflight)
+            self.app.router.add_get('/api/file-content', self._handle_file_content)
+            self.app.router.add_options('/api/file-content', self._handle_cors_preflight)
             
             # Add dashboard routes
             self.app.router.add_get('/', self._handle_dashboard)
@@ -310,6 +340,10 @@ class SocketIOServer:
             "port": self.port,
             "host": self.host,
             "clients_connected": len(self.clients)
+        }, headers={
+            'Access-Control-Allow-Origin': '*',
+            'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+            'Access-Control-Allow-Headers': 'Content-Type, Accept'
         })
 
     async def _handle_dashboard(self, request):
@@ -321,6 +355,18 @@ class SocketIOServer:
             return web.FileResponse(str(dashboard_path))
         else:
             return web.Response(text=f"Dashboard not found at: {dashboard_path}", status=404)
+    
+    async def _handle_cors_preflight(self, request):
+        """Handle CORS preflight requests."""
+        return web.Response(
+            status=200,
+            headers={
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, Accept, Authorization',
+                'Access-Control-Max-Age': '86400'
+            }
+        )
         
     async def _handle_git_diff(self, request):
         """Handle git diff requests for file operations.
@@ -336,23 +382,237 @@ class SocketIOServer:
             timestamp = request.query.get('timestamp')
             working_dir = request.query.get('working_dir', os.getcwd())
             
+            self.logger.info(f"Git diff API request: file={file_path}, timestamp={timestamp}, working_dir={working_dir}")
+            self.logger.info(f"Git diff request details: query_params={dict(request.query)}, file_exists={os.path.exists(file_path) if file_path else False}")
+            
             if not file_path:
+                self.logger.warning("Git diff request missing file parameter")
                 return web.json_response({
+                    "success": False,
                     "error": "Missing required parameter: file"
-                }, status=400)
+                }, status=400, headers={
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                    'Access-Control-Allow-Headers': 'Content-Type, Accept'
+                })
             
             self.logger.debug(f"Git diff requested for file: {file_path}, timestamp: {timestamp}")
             
             # Generate git diff using the _generate_git_diff helper
             diff_result = await self._generate_git_diff(file_path, timestamp, working_dir)
             
-            return web.json_response(diff_result)
+            self.logger.info(f"Git diff result: success={diff_result.get('success', False)}, method={diff_result.get('method', 'unknown')}")
+            
+            return web.json_response(diff_result, headers={
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, Accept'
+            })
             
         except Exception as e:
             self.logger.error(f"Error generating git diff: {e}")
+            import traceback
+            self.logger.error(f"Git diff error traceback: {traceback.format_exc()}")
             return web.json_response({
+                "success": False,
                 "error": f"Failed to generate git diff: {str(e)}"
-            }, status=500)
+            }, status=500, headers={
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, Accept'
+            })
+    
+    async def _handle_file_content(self, request):
+        """Handle file content requests via HTTP API.
+        
+        Expected query parameters:
+        - file_path: The file path to read
+        - working_dir: Working directory for file operations (optional)
+        - max_size: Maximum file size in bytes (optional, default 1MB)
+        """
+        try:
+            # Extract query parameters
+            file_path = request.query.get('file_path')
+            working_dir = request.query.get('working_dir', os.getcwd())
+            max_size = int(request.query.get('max_size', 1024 * 1024))  # 1MB default
+            
+            self.logger.info(f"File content API request: file_path={file_path}, working_dir={working_dir}")
+            
+            if not file_path:
+                self.logger.warning("File content request missing file_path parameter")
+                return web.json_response({
+                    "success": False,
+                    "error": "Missing required parameter: file_path"
+                }, status=400, headers={
+                    'Access-Control-Allow-Origin': '*',
+                    'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                    'Access-Control-Allow-Headers': 'Content-Type, Accept'
+                })
+            
+            # Use the same file reading logic as the Socket.IO handler
+            result = await self._read_file_safely(file_path, working_dir, max_size)
+            
+            status_code = 200 if result.get('success') else 400
+            return web.json_response(result, status=status_code, headers={
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',  
+                'Access-Control-Allow-Headers': 'Content-Type, Accept'
+            })
+            
+        except Exception as e:
+            self.logger.error(f"Error reading file content: {e}")
+            import traceback
+            self.logger.error(f"File content error traceback: {traceback.format_exc()}")
+            return web.json_response({
+                "success": False,
+                "error": f"Failed to read file: {str(e)}"
+            }, status=500, headers={
+                'Access-Control-Allow-Origin': '*',
+                'Access-Control-Allow-Methods': 'GET, POST, OPTIONS',
+                'Access-Control-Allow-Headers': 'Content-Type, Accept'
+            })
+    
+    async def _read_file_safely(self, file_path: str, working_dir: str = None, max_size: int = 1024 * 1024):
+        """Safely read file content with security checks.
+        
+        This method contains the core file reading logic that can be used by both
+        HTTP API endpoints and Socket.IO event handlers.
+        
+        Args:
+            file_path: Path to the file to read
+            working_dir: Working directory (defaults to current directory)
+            max_size: Maximum file size in bytes
+            
+        Returns:
+            dict: Response with success status, content, and metadata
+        """
+        try:
+            if working_dir is None:
+                working_dir = os.getcwd()
+                
+            # Resolve absolute path based on working directory
+            if not os.path.isabs(file_path):
+                full_path = os.path.join(working_dir, file_path)
+            else:
+                full_path = file_path
+            
+            # Security check: ensure file is within working directory or project
+            try:
+                real_path = os.path.realpath(full_path)
+                real_working_dir = os.path.realpath(working_dir)
+                
+                # Allow access to files within working directory or the project root
+                project_root = os.path.realpath(get_project_root())
+                allowed_paths = [real_working_dir, project_root]
+                
+                is_allowed = any(real_path.startswith(allowed_path) for allowed_path in allowed_paths)
+                
+                if not is_allowed:
+                    return {
+                        'success': False,
+                        'error': 'Access denied: file is outside allowed directories',
+                        'file_path': file_path
+                    }
+                    
+            except Exception as path_error:
+                self.logger.error(f"Path validation error: {path_error}")
+                return {
+                    'success': False,
+                    'error': 'Invalid file path',
+                    'file_path': file_path
+                }
+            
+            # Check if file exists
+            if not os.path.exists(real_path):
+                return {
+                    'success': False,
+                    'error': 'File does not exist',
+                    'file_path': file_path
+                }
+            
+            # Check if it's a file (not directory)
+            if not os.path.isfile(real_path):
+                return {
+                    'success': False,
+                    'error': 'Path is not a file',
+                    'file_path': file_path
+                }
+            
+            # Check file size
+            file_size = os.path.getsize(real_path)
+            if file_size > max_size:
+                return {
+                    'success': False,
+                    'error': f'File too large ({file_size} bytes). Maximum allowed: {max_size} bytes',
+                    'file_path': file_path,
+                    'file_size': file_size
+                }
+            
+            # Read file content
+            try:
+                with open(real_path, 'r', encoding='utf-8') as f:
+                    content = f.read()
+                
+                # Get file extension for syntax highlighting hint
+                _, ext = os.path.splitext(real_path)
+                
+                return {
+                    'success': True,
+                    'file_path': file_path,
+                    'content': content,
+                    'file_size': file_size,
+                    'extension': ext.lower(),
+                    'encoding': 'utf-8'
+                }
+                
+            except UnicodeDecodeError:
+                # Try reading as binary if UTF-8 fails
+                try:
+                    with open(real_path, 'rb') as f:
+                        binary_content = f.read()
+                    
+                    # Check if it's a text file by looking for common text patterns
+                    try:
+                        text_content = binary_content.decode('latin-1')
+                        if '\x00' in text_content:
+                            # Binary file
+                            return {
+                                'success': False,
+                                'error': 'File appears to be binary and cannot be displayed as text',
+                                'file_path': file_path,
+                                'file_size': file_size
+                            }
+                        else:
+                            # Text file with different encoding
+                            _, ext = os.path.splitext(real_path)
+                            return {
+                                'success': True,
+                                'file_path': file_path,
+                                'content': text_content,
+                                'file_size': file_size,
+                                'extension': ext.lower(),
+                                'encoding': 'latin-1'
+                            }
+                    except Exception:
+                        return {
+                            'success': False,
+                            'error': 'File encoding not supported',
+                            'file_path': file_path
+                        }
+                except Exception as read_error:
+                    return {
+                        'success': False,
+                        'error': f'Failed to read file: {str(read_error)}',
+                        'file_path': file_path
+                    }
+                    
+        except Exception as e:
+            self.logger.error(f"Error in _read_file_safely: {e}")
+            return {
+                'success': False,
+                'error': str(e),
+                'file_path': file_path
+            }
     
     async def _generate_git_diff(self, file_path: str, timestamp: Optional[str] = None, working_dir: str = None):
         """Generate git diff for a specific file operation.
@@ -370,17 +630,36 @@ class SocketIOServer:
             dict: Contains diff content, metadata, and status information
         """
         try:
+            # If file_path is absolute, determine its git repository
+            if os.path.isabs(file_path):
+                # Find the directory containing the file
+                file_dir = os.path.dirname(file_path)
+                if os.path.exists(file_dir):
+                    # Try to find the git root from the file's directory
+                    current_dir = file_dir
+                    while current_dir != "/" and current_dir:
+                        if os.path.exists(os.path.join(current_dir, ".git")):
+                            working_dir = current_dir
+                            self.logger.info(f"Found git repository at: {working_dir}")
+                            break
+                        current_dir = os.path.dirname(current_dir)
+                    else:
+                        # If no git repo found, use the file's directory
+                        working_dir = file_dir
+                        self.logger.info(f"No git repo found, using file's directory: {working_dir}")
+            
             if working_dir is None:
                 working_dir = os.getcwd()
                 
-            # Change to the working directory
+            # For read-only git operations, we can work from any directory
+            # by passing the -C flag to git commands instead of changing directories
             original_cwd = os.getcwd()
             try:
-                os.chdir(working_dir)
+                # We'll use git -C <working_dir> for all commands instead of chdir
                 
                 # Check if this is a git repository
                 git_check = await asyncio.create_subprocess_exec(
-                    'git', 'rev-parse', '--git-dir',
+                    'git', '-C', working_dir, 'rev-parse', '--git-dir',
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE
                 )
@@ -388,6 +667,7 @@ class SocketIOServer:
                 
                 if git_check.returncode != 0:
                     return {
+                        "success": False,
                         "error": "Not a git repository",
                         "file_path": file_path,
                         "working_dir": working_dir
@@ -395,14 +675,14 @@ class SocketIOServer:
                 
                 # Get the absolute path of the file relative to git root
                 git_root_proc = await asyncio.create_subprocess_exec(
-                    'git', 'rev-parse', '--show-toplevel',
+                    'git', '-C', working_dir, 'rev-parse', '--show-toplevel',
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE
                 )
                 git_root_output, _ = await git_root_proc.communicate()
                 
                 if git_root_proc.returncode != 0:
-                    return {"error": "Failed to determine git root directory"}
+                    return {"success": False, "error": "Failed to determine git root directory"}
                 
                 git_root = git_root_output.decode().strip()
                 
@@ -424,7 +704,7 @@ class SocketIOServer:
                         
                         # Find commits that modified this file around the timestamp
                         log_proc = await asyncio.create_subprocess_exec(
-                            'git', 'log', '--oneline', '--since', git_since, 
+                            'git', '-C', working_dir, 'log', '--oneline', '--since', git_since, 
                             '--until', f'{git_since} +1 hour', '--', file_path,
                             stdout=asyncio.subprocess.PIPE,
                             stderr=asyncio.subprocess.PIPE
@@ -439,7 +719,7 @@ class SocketIOServer:
                                 
                                 # Get the diff for this specific commit
                                 diff_proc = await asyncio.create_subprocess_exec(
-                                    'git', 'show', '--format=fuller', commit_hash, '--', file_path,
+                                    'git', '-C', working_dir, 'show', '--format=fuller', commit_hash, '--', file_path,
                                     stdout=asyncio.subprocess.PIPE,
                                     stderr=asyncio.subprocess.PIPE
                                 )
@@ -459,7 +739,7 @@ class SocketIOServer:
                 
                 # Fallback: Get the most recent change to the file
                 log_proc = await asyncio.create_subprocess_exec(
-                    'git', 'log', '-1', '--oneline', '--', file_path,
+                    'git', '-C', working_dir, 'log', '-1', '--oneline', '--', file_path,
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE
                 )
@@ -470,7 +750,7 @@ class SocketIOServer:
                     
                     # Get the diff for the most recent commit
                     diff_proc = await asyncio.create_subprocess_exec(
-                        'git', 'show', '--format=fuller', commit_hash, '--', file_path,
+                        'git', '-C', working_dir, 'show', '--format=fuller', commit_hash, '--', file_path,
                         stdout=asyncio.subprocess.PIPE,
                         stderr=asyncio.subprocess.PIPE
                     )
@@ -486,9 +766,45 @@ class SocketIOServer:
                             "timestamp": timestamp
                         }
                 
-                # Final fallback: Show current working directory changes
+                # Try to show unstaged changes first
                 diff_proc = await asyncio.create_subprocess_exec(
-                    'git', 'diff', 'HEAD', '--', file_path,
+                    'git', '-C', working_dir, 'diff', '--', file_path,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE
+                )
+                diff_output, _ = await diff_proc.communicate()
+                
+                if diff_proc.returncode == 0 and diff_output.decode().strip():
+                    return {
+                        "success": True,
+                        "diff": diff_output.decode(),
+                        "commit_hash": "unstaged_changes",
+                        "file_path": file_path,
+                        "method": "unstaged_changes",
+                        "timestamp": timestamp
+                    }
+                
+                # Then try staged changes
+                diff_proc = await asyncio.create_subprocess_exec(
+                    'git', '-C', working_dir, 'diff', '--cached', '--', file_path,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE
+                )
+                diff_output, _ = await diff_proc.communicate()
+                
+                if diff_proc.returncode == 0 and diff_output.decode().strip():
+                    return {
+                        "success": True,
+                        "diff": diff_output.decode(),
+                        "commit_hash": "staged_changes",
+                        "file_path": file_path,
+                        "method": "staged_changes",
+                        "timestamp": timestamp
+                    }
+                
+                # Final fallback: Show changes against HEAD
+                diff_proc = await asyncio.create_subprocess_exec(
+                    'git', '-C', working_dir, 'diff', 'HEAD', '--', file_path,
                     stdout=asyncio.subprocess.PIPE,
                     stderr=asyncio.subprocess.PIPE
                 )
@@ -506,14 +822,58 @@ class SocketIOServer:
                             "timestamp": timestamp
                         }
                 
+                # Check if file is tracked by git
+                status_proc = await asyncio.create_subprocess_exec(
+                    'git', '-C', working_dir, 'ls-files', '--', file_path,
+                    stdout=asyncio.subprocess.PIPE,
+                    stderr=asyncio.subprocess.PIPE
+                )
+                status_output, _ = await status_proc.communicate()
+                
+                is_tracked = status_proc.returncode == 0 and status_output.decode().strip()
+                
+                if not is_tracked:
+                    # File is not tracked by git
+                    return {
+                        "success": False,
+                        "error": "This file is not tracked by git",
+                        "file_path": file_path,
+                        "working_dir": working_dir,
+                        "suggestions": [
+                            "This file has not been added to git yet",
+                            "Use 'git add' to track this file before viewing its diff",
+                            "Git diff can only show changes for files that are tracked by git"
+                        ]
+                    }
+                
+                # File is tracked but has no changes to show
+                suggestions = [
+                    "The file may not have any committed changes yet",
+                    "The file may have been added but not committed",
+                    "The timestamp may be outside the git history range"
+                ]
+                
+                if os.path.isabs(file_path) and not file_path.startswith(os.getcwd()):
+                    current_repo = os.path.basename(os.getcwd())
+                    file_repo = "unknown"
+                    # Try to extract repository name from path
+                    path_parts = file_path.split("/")
+                    if "Projects" in path_parts:
+                        idx = path_parts.index("Projects")
+                        if idx + 1 < len(path_parts):
+                            file_repo = path_parts[idx + 1]
+                    
+                    suggestions.clear()
+                    suggestions.append(f"This file is from the '{file_repo}' repository")
+                    suggestions.append(f"The git diff viewer is running from the '{current_repo}' repository")
+                    suggestions.append("Git diff can only show changes for files in the current repository")
+                    suggestions.append("To view changes for this file, run the monitoring dashboard from its repository")
+                
                 return {
+                    "success": False,
                     "error": "No git history found for this file",
                     "file_path": file_path,
-                    "suggestions": [
-                        "The file may not be tracked by git",
-                        "The file may not have any committed changes",
-                        "The timestamp may be outside the git history range"
-                    ]
+                    "suggestions": suggestions
                 }
                 
             finally:
@@ -522,6 +882,7 @@ class SocketIOServer:
         except Exception as e:
             self.logger.error(f"Error in _generate_git_diff: {e}")
             return {
+                "success": False,
                 "error": f"Git diff generation failed: {str(e)}",
                 "file_path": file_path
             }
@@ -630,6 +991,245 @@ class SocketIOServer:
             
             # Re-broadcast to all other clients
             await self.sio.emit('claude_event', data, skip_sid=sid)
+        
+        @self.sio.event
+        async def get_git_branch(sid, working_dir=None):
+            """Get the current git branch for a directory"""
+            import subprocess
+            try:
+                self.logger.info(f"[GIT-BRANCH-DEBUG] get_git_branch called with working_dir: {repr(working_dir)} (type: {type(working_dir)})")
+                
+                # Handle case where working_dir is None, empty string, or 'Unknown'
+                original_working_dir = working_dir
+                if not working_dir or working_dir == 'Unknown' or working_dir.strip() == '':
+                    working_dir = os.getcwd()
+                    self.logger.info(f"[GIT-BRANCH-DEBUG] working_dir was invalid ({repr(original_working_dir)}), using cwd: {working_dir}")
+                else:
+                    self.logger.info(f"[GIT-BRANCH-DEBUG] Using provided working_dir: {working_dir}")
+                
+                # Validate that the directory exists and is a valid path
+                if not os.path.exists(working_dir):
+                    self.logger.warning(f"[GIT-BRANCH-DEBUG] Directory does not exist: {working_dir}")
+                    await self.sio.emit('git_branch_response', {
+                        'success': False,
+                        'error': f'Directory does not exist: {working_dir}',
+                        'working_dir': working_dir,
+                        'original_working_dir': original_working_dir
+                    }, room=sid)
+                    return
+                    
+                if not os.path.isdir(working_dir):
+                    self.logger.warning(f"[GIT-BRANCH-DEBUG] Path is not a directory: {working_dir}")
+                    await self.sio.emit('git_branch_response', {
+                        'success': False,
+                        'error': f'Path is not a directory: {working_dir}',
+                        'working_dir': working_dir,
+                        'original_working_dir': original_working_dir
+                    }, room=sid)
+                    return
+                
+                self.logger.info(f"[GIT-BRANCH-DEBUG] Running git command in directory: {working_dir}")
+                
+                # Run git command to get current branch
+                result = subprocess.run(
+                    ["git", "rev-parse", "--abbrev-ref", "HEAD"],
+                    cwd=working_dir,
+                    capture_output=True,
+                    text=True
+                )
+                
+                self.logger.info(f"[GIT-BRANCH-DEBUG] Git command result: returncode={result.returncode}, stdout={repr(result.stdout)}, stderr={repr(result.stderr)}")
+                
+                if result.returncode == 0:
+                    branch = result.stdout.strip()
+                    self.logger.info(f"[GIT-BRANCH-DEBUG] Successfully got git branch: {branch}")
+                    await self.sio.emit('git_branch_response', {
+                        'success': True,
+                        'branch': branch,
+                        'working_dir': working_dir,
+                        'original_working_dir': original_working_dir
+                    }, room=sid)
+                else:
+                    self.logger.warning(f"[GIT-BRANCH-DEBUG] Git command failed: {result.stderr}")
+                    await self.sio.emit('git_branch_response', {
+                        'success': False,
+                        'error': 'Not a git repository',
+                        'working_dir': working_dir,
+                        'original_working_dir': original_working_dir,
+                        'git_error': result.stderr
+                    }, room=sid)
+                    
+            except Exception as e:
+                self.logger.error(f"[GIT-BRANCH-DEBUG] Exception in get_git_branch: {e}")
+                import traceback
+                self.logger.error(f"[GIT-BRANCH-DEBUG] Stack trace: {traceback.format_exc()}")
+                await self.sio.emit('git_branch_response', {
+                    'success': False,
+                    'error': str(e),
+                    'working_dir': working_dir,
+                    'original_working_dir': original_working_dir
+                }, room=sid)
+        
+        @self.sio.event
+        async def check_file_tracked(sid, data):
+            """Check if a file is tracked by git"""
+            import subprocess
+            try:
+                file_path = data.get('file_path')
+                working_dir = data.get('working_dir', os.getcwd())
+                
+                if not file_path:
+                    await self.sio.emit('file_tracked_response', {
+                        'success': False,
+                        'error': 'file_path is required',
+                        'file_path': file_path
+                    }, room=sid)
+                    return
+                
+                # Use git ls-files to check if file is tracked
+                result = subprocess.run(
+                    ["git", "-C", working_dir, "ls-files", "--", file_path],
+                    capture_output=True,
+                    text=True
+                )
+                
+                is_tracked = result.returncode == 0 and result.stdout.strip()
+                
+                await self.sio.emit('file_tracked_response', {
+                    'success': True,
+                    'file_path': file_path,
+                    'working_dir': working_dir,
+                    'is_tracked': bool(is_tracked)
+                }, room=sid)
+                    
+            except Exception as e:
+                self.logger.error(f"Error checking file tracked status: {e}")
+                await self.sio.emit('file_tracked_response', {
+                    'success': False,
+                    'error': str(e),
+                    'file_path': data.get('file_path', 'unknown')
+                }, room=sid)
+        
+        @self.sio.event
+        async def read_file(sid, data):
+            """Read file contents safely"""
+            try:
+                file_path = data.get('file_path')
+                working_dir = data.get('working_dir', os.getcwd())
+                max_size = data.get('max_size', 1024 * 1024)  # 1MB default limit
+                
+                if not file_path:
+                    await self.sio.emit('file_content_response', {
+                        'success': False,
+                        'error': 'file_path is required',
+                        'file_path': file_path
+                    }, room=sid)
+                    return
+                
+                # Use the shared file reading logic
+                result = await self._read_file_safely(file_path, working_dir, max_size)
+                
+                # Send the result back to the client
+                await self.sio.emit('file_content_response', result, room=sid)
+                        
+            except Exception as e:
+                self.logger.error(f"Error reading file: {e}")
+                await self.sio.emit('file_content_response', {
+                    'success': False,
+                    'error': str(e),
+                    'file_path': data.get('file_path', 'unknown')
+                }, room=sid)
+        
+        @self.sio.event
+        async def git_add_file(sid, data):
+            """Add file to git tracking"""
+            import subprocess
+            try:
+                file_path = data.get('file_path')
+                working_dir = data.get('working_dir', os.getcwd())
+                
+                self.logger.info(f"[GIT-ADD-DEBUG] git_add_file called with file_path: {repr(file_path)}, working_dir: {repr(working_dir)} (type: {type(working_dir)})")
+                
+                if not file_path:
+                    await self.sio.emit('git_add_response', {
+                        'success': False,
+                        'error': 'file_path is required',
+                        'file_path': file_path
+                    }, room=sid)
+                    return
+                
+                # Validate and sanitize working_dir
+                original_working_dir = working_dir
+                if not working_dir or working_dir == 'Unknown' or working_dir.strip() == '' or working_dir == '.':
+                    working_dir = os.getcwd()
+                    self.logger.info(f"[GIT-ADD-DEBUG] working_dir was invalid ({repr(original_working_dir)}), using cwd: {working_dir}")
+                else:
+                    self.logger.info(f"[GIT-ADD-DEBUG] Using provided working_dir: {working_dir}")
+                
+                # Validate that the directory exists and is a valid path
+                if not os.path.exists(working_dir):
+                    self.logger.warning(f"[GIT-ADD-DEBUG] Directory does not exist: {working_dir}")
+                    await self.sio.emit('git_add_response', {
+                        'success': False,
+                        'error': f'Directory does not exist: {working_dir}',
+                        'file_path': file_path,
+                        'working_dir': working_dir,
+                        'original_working_dir': original_working_dir
+                    }, room=sid)
+                    return
+                    
+                if not os.path.isdir(working_dir):
+                    self.logger.warning(f"[GIT-ADD-DEBUG] Path is not a directory: {working_dir}")
+                    await self.sio.emit('git_add_response', {
+                        'success': False,
+                        'error': f'Path is not a directory: {working_dir}',
+                        'file_path': file_path,
+                        'working_dir': working_dir,
+                        'original_working_dir': original_working_dir
+                    }, room=sid)
+                    return
+                
+                self.logger.info(f"[GIT-ADD-DEBUG] Running git add command in directory: {working_dir}")
+                
+                # Use git add to track the file
+                result = subprocess.run(
+                    ["git", "-C", working_dir, "add", file_path],
+                    capture_output=True,
+                    text=True
+                )
+                
+                self.logger.info(f"[GIT-ADD-DEBUG] Git add result: returncode={result.returncode}, stdout={repr(result.stdout)}, stderr={repr(result.stderr)}")
+                
+                if result.returncode == 0:
+                    self.logger.info(f"[GIT-ADD-DEBUG] Successfully added {file_path} to git in {working_dir}")
+                    await self.sio.emit('git_add_response', {
+                        'success': True,
+                        'file_path': file_path,
+                        'working_dir': working_dir,
+                        'original_working_dir': original_working_dir,
+                        'message': 'File successfully added to git tracking'
+                    }, room=sid)
+                else:
+                    error_message = result.stderr.strip() or 'Unknown git error'
+                    self.logger.warning(f"[GIT-ADD-DEBUG] Git add failed: {error_message}")
+                    await self.sio.emit('git_add_response', {
+                        'success': False,
+                        'error': f'Git add failed: {error_message}',
+                        'file_path': file_path,
+                        'working_dir': working_dir,
+                        'original_working_dir': original_working_dir
+                    }, room=sid)
+                    
+            except Exception as e:
+                self.logger.error(f"[GIT-ADD-DEBUG] Exception in git_add_file: {e}")
+                import traceback
+                self.logger.error(f"[GIT-ADD-DEBUG] Stack trace: {traceback.format_exc()}")
+                await self.sio.emit('git_add_response', {
+                    'success': False,
+                    'error': str(e),
+                    'file_path': data.get('file_path', 'unknown'),
+                    'working_dir': data.get('working_dir', 'unknown')
+                }, room=sid)
             
     async def _send_current_status(self, sid: str):
         """Send current system status to a client."""
@@ -737,18 +1337,22 @@ class SocketIOServer:
         
         # Broadcast to clients with timeout and error handling
         try:
-            future = asyncio.run_coroutine_threadsafe(
-                self.sio.emit('claude_event', event),
-                self.loop
-            )
-            # Wait for completion with timeout to detect issues
-            try:
-                future.result(timeout=2.0)  # 2 second timeout
-                self.logger.debug(f"📨 Successfully broadcasted {event_type} to {len(self.clients)} clients")
-            except asyncio.TimeoutError:
-                self.logger.warning(f"⏰ Broadcast timeout for event {event_type} - continuing anyway")
-            except Exception as emit_error:
-                self.logger.error(f"❌ Broadcast emit error for {event_type}: {emit_error}")
+            # Check if the event loop is still running and not closed
+            if self.loop and not self.loop.is_closed() and self.loop.is_running():
+                future = asyncio.run_coroutine_threadsafe(
+                    self.sio.emit('claude_event', event),
+                    self.loop
+                )
+                # Wait for completion with timeout to detect issues
+                try:
+                    future.result(timeout=2.0)  # 2 second timeout
+                    self.logger.debug(f"📨 Successfully broadcasted {event_type} to {len(self.clients)} clients")
+                except asyncio.TimeoutError:
+                    self.logger.warning(f"⏰ Broadcast timeout for event {event_type} - continuing anyway")
+                except Exception as emit_error:
+                    self.logger.error(f"❌ Broadcast emit error for {event_type}: {emit_error}")
+            else:
+                self.logger.warning(f"⚠️ Event loop not available for broadcast of {event_type} - event loop closed or not running")
         except Exception as e:
             self.logger.error(f"❌ Failed to submit broadcast to event loop: {e}")
             import traceback
@@ -919,4 +1523,4 @@ def stop_socketio_server():
     global _socketio_server
     if _socketio_server:
         _socketio_server.stop()
-        _socketio_server = None
+        _socketio_server = None