@embedder/embedder 1.1.1 → 2.0.6

package/bundle/gdb-debugger-python/gdb_bridge.py

@@ -1,392 +0,0 @@
-#!/usr/bin/env python3
-"""
-Enhanced GDB Bridge for Embedder CLI Debugger with Embedded System Support
-Supports both local debugging and remote debugging for embedded targets.
-"""
-
-import argparse
-import json
-import sys
-import os
-import signal
-import threading
-import time
-from typing import Dict, Any, Optional
-import pygdbmi
-from pygdbmi.gdbcontroller import GdbController
-
-class EmbeddedGDBBridge:
-    def __init__(self, executable: str, working_dir: Optional[str] = None, 
-                 remote_mode: bool = False, host: str = 'localhost', 
-                 port: int = 3333, gdb_command: str = 'gdb'):
-        self.executable = executable
-        self.working_dir = working_dir
-        self.remote_mode = remote_mode
-        self.host = host
-        self.port = port
-        self.gdb_command = gdb_command
-        self.gdb_controller: Optional[GdbController] = None
-        self.running = True
-        self.log_file_path = os.path.join(os.getcwd(), 'log.txt')
-        
-        # Initialize stderr logging
-        self._init_stderr_logging()
-        
-    def _init_stderr_logging(self):
-        """Initialize stderr logging to log.txt file"""
-        try:
-            log_header = f"\n[{time.strftime('%Y-%m-%dT%H:%M:%S')}] Python GDB Bridge Starting\n"
-            with open(self.log_file_path, 'a') as log_file:
-                log_file.write(log_header)
-        except Exception as e:
-            print(f"[WARNING] Failed to initialize stderr log file: {e}", file=sys.stderr)
-    
-    def _log_to_file(self, message: str, level: str = "INFO"):
-        """Log a message to the stderr log file"""
-        try:
-            timestamp = time.strftime('%Y-%m-%dT%H:%M:%S')
-            log_entry = f"[{timestamp}] [Python Bridge {level}] {message}\n"
-            with open(self.log_file_path, 'a') as log_file:
-                log_file.write(log_entry)
-        except Exception as e:
-            print(f"[WARNING] Failed to write to log file: {e}", file=sys.stderr)
-        
-    def initialize(self):
-        """Initialize GDB controller and set up debugging session"""
-        try:
-            self._log_to_file("Starting GDB bridge initialization")
-            
-            # Create GDB controller with appropriate command
-            gdb_path = self.gdb_command.split()[0] if ' ' in self.gdb_command else self.gdb_command
-            
-            # Debug: Print what we're trying to execute
-            debug_msg = f"gdb_command: '{self.gdb_command}' (type: {type(self.gdb_command)}, len: {len(self.gdb_command)})"
-            print(f"[DEBUG] {debug_msg}", file=sys.stderr, flush=True)
-            self._log_to_file(debug_msg, "DEBUG")
-            
-            debug_msg = f"gdb_path: '{gdb_path}' (type: {type(gdb_path)}, len: {len(gdb_path)})"
-            print(f"[DEBUG] {debug_msg}", file=sys.stderr, flush=True)
-            self._log_to_file(debug_msg, "DEBUG")
-            
-            # Try different ways to pass the command to handle potential compatibility issues
-            try:
-                # Always request an MI interpreter if the caller forgot; pygdbmi
-                # expects structured output.  We detect a missing flag crudely
-                # and append '--interpreter=mi2'.
-                cmd_parts = gdb_path.split()
-                if '--interpreter' not in ' '.join(cmd_parts):
-                    cmd_parts += ['--interpreter=mi2']
-
-                debug_msg = f"Attempting to create GdbController with command={cmd_parts}"
-                print(f"[DEBUG] {debug_msg}", file=sys.stderr, flush=True)
-                self._log_to_file(debug_msg, "DEBUG")
-                # Give GDB a more generous timeout for large ELF symbol tables
-                self.gdb_controller = GdbController(command=cmd_parts)
-            except Exception as e1:
-                error_msg = f"Failed with command='{gdb_path}': {e1}"
-                print(f"[DEBUG] {error_msg}", file=sys.stderr, flush=True)
-                self._log_to_file(error_msg, "ERROR")
-                try:
-                    cmd_parts = gdb_path.split()
-                    if '--interpreter' not in ' '.join(cmd_parts):
-                        cmd_parts += ['--interpreter=mi2']
-
-                    debug_msg = f"Attempting to create GdbController with command={cmd_parts}"
-                    print(f"[DEBUG] {debug_msg}", file=sys.stderr, flush=True)
-                    self._log_to_file(debug_msg, "DEBUG")
-                    self.gdb_controller = GdbController(command=cmd_parts)
-                except Exception as e2:
-                    error_msg = f"Failed with command=['{gdb_path}']: {e2}"
-                    print(f"[DEBUG] {error_msg}", file=sys.stderr, flush=True)
-                    self._log_to_file(error_msg, "ERROR")
-                    try:
-                        debug_msg = "Attempting to create GdbController with default constructor"
-                        print(f"[DEBUG] {debug_msg}", file=sys.stderr, flush=True)
-                        self._log_to_file(debug_msg, "DEBUG")
-                        self.gdb_controller = GdbController()
-                    except Exception as e3:
-                        error_msg = f"Failed with default constructor: {e3}"
-                        print(f"[DEBUG] {error_msg}", file=sys.stderr, flush=True)
-                        self._log_to_file(error_msg, "ERROR")
-                        
-                        # Provide helpful error message for embedded debugging
-                        error_msg = f"Failed to initialize GDB with command '{gdb_path}'. "
-                        if gdb_path == 'gdb':
-                            error_msg += "For embedded debugging, you may need to:\n"
-                            error_msg += "1. Create an EMBEDDER.md file in your project root with embedded debugging configuration\n"
-                            error_msg += "2. Install GDB for your target architecture (e.g., arm-none-eabi-gdb)\n"
-                            error_msg += "3. Ensure the GDB executable is in your PATH"
-                        
-                        self._log_to_file(error_msg, "ERROR")
-                        raise Exception(error_msg)
-            
-            self._log_to_file("✅ GDB controller created successfully")
-            print(f"[DEBUG] ✅ GDB controller created successfully", file=sys.stderr, flush=True)
-            
-            # Check if executable file exists before loading
-            if not os.path.exists(self.executable):
-                error_msg = f"Executable file not found: {self.executable}"
-                self._log_to_file(error_msg, "ERROR")
-                print(f"[ERROR] {error_msg}", file=sys.stderr, flush=True)
-                raise Exception(error_msg)
-            
-            # Get file size for logging
-            file_size = os.path.getsize(self.executable)
-            self._log_to_file(f"Executable file exists, size: {file_size} bytes")
-            print(f"[DEBUG] Executable file exists, size: {file_size} bytes", file=sys.stderr, flush=True)
-            
-            # Load executable with enhanced error handling
-            try:
-                self._log_to_file(f"Loading executable: {self.executable}")
-                print(f"[DEBUG] Loading executable: {self.executable}", file=sys.stderr, flush=True)
-                
-                load_cmd = f'-file-exec-and-symbols {self.executable}'
-                self._log_to_file(f"Executing GDB command: {load_cmd}")
-                print(f"[DEBUG] Executing GDB command: {load_cmd}", file=sys.stderr, flush=True)
-                
-                response = self.gdb_controller.write(load_cmd, timeout_sec=30)  # Increased timeout
-                self._log_to_file(f"✅ Executable load response received, length: {len(response) if response else 0}")
-                print(f"[DEBUG] ✅ Executable load response received", file=sys.stderr, flush=True)
-                
-                self._send_response('gdb_response', response)
-                
-                # Check if load was successful
-                if response and isinstance(response, list):
-                    error_responses = [r for r in response if r.get('message') == 'error']
-                    if error_responses:
-                        error_msg = f"Failed to load executable: {error_responses}"
-                        self._log_to_file(error_msg, "ERROR")
-                        print(f"[ERROR] {error_msg}", file=sys.stderr, flush=True)
-                        raise Exception(error_msg)
-                
-            except Exception as e:
-                error_msg = f"Failed to load executable: {str(e)}"
-                self._log_to_file(error_msg, "ERROR")
-                print(f"[ERROR] {error_msg}", file=sys.stderr, flush=True)
-                raise Exception(error_msg)
-            
-            if self.remote_mode:
-                try:
-                    # Connect to remote target (embedded system)
-                    target_cmd = f'-target-select remote {self.host}:{self.port}'
-                    self._log_to_file(f"Connecting to remote target: {target_cmd}")
-                    print(f"[DEBUG] Connecting to remote target: {target_cmd}", file=sys.stderr, flush=True)
-                    
-                    response = self.gdb_controller.write(target_cmd, timeout_sec=15)
-                    self._log_to_file(f"✅ Remote target connection response received")
-                    print(f"[DEBUG] ✅ Remote target connection response received", file=sys.stderr, flush=True)
-                    
-                    self._send_response('gdb_response', response)
-
-                    # Check if connection was successful
-                    if response and isinstance(response, list):
-                        error_responses = [r for r in response if r.get('message') == 'error']
-                        if error_responses:
-                            error_msg = f"Failed to connect to remote target: {error_responses}"
-                            self._log_to_file(error_msg, "ERROR")
-                            print(f"[ERROR] {error_msg}", file=sys.stderr, flush=True)
-                            raise Exception(error_msg)
-
-                    # Program is no longer loaded automatically. This will be handled by the client.
-
-                    # Send remote connection event
-                    self._send_event('remote_connected', {
-                        'host': self.host, 
-                        'port': self.port,
-                        'executable': self.executable
-                    })
-                    
-                except Exception as e:
-                    error_msg = f"Failed during remote target setup: {str(e)}"
-                    self._log_to_file(error_msg, "ERROR")
-                    print(f"[ERROR] {error_msg}", file=sys.stderr, flush=True)
-                    raise Exception(error_msg)
-            
-            # Send initialization complete event
-            self._send_event('initialized', {
-                'mode': 'remote' if self.remote_mode else 'local',
-                'executable': self.executable,
-                'working_dir': self.working_dir,
-                'gdb_command': self.gdb_command,
-                'timestamp': str(time.time())
-            })
-            
-            success_msg = f"GDB client fully initialized in {'remote' if self.remote_mode else 'local'} mode"
-            print(f"[GDB-Bridge] ✅ {success_msg}", file=sys.stderr, flush=True)
-            self._log_to_file(success_msg, "SUCCESS")
-            
-        except Exception as e:
-            error_msg = f"Failed to initialize GDB: {str(e)}"
-            self._log_to_file(error_msg, "ERROR")
-            print(f"[GDB-Bridge] ❌ {error_msg}", file=sys.stderr, flush=True)
-            self._send_error(error_msg)
-            sys.exit(1)
-
-    def _send_response(self, type: str, response: Dict[str, Any]):
-        """Helper to send a response to stdout."""
-        output = {
-            'type': type,
-            'payload': response
-        }
-        print(json.dumps(output), flush=True)
-
-    def _send_event(self, event_type: str, payload: Dict[str, Any]):
-        """Helper to send an event to stdout."""
-        output = {
-            'type': 'event',
-            'event': event_type,
-            'payload': payload
-        }
-        print(json.dumps(output), flush=True)
-
-    def _send_error(self, message: str):
-        """Helper to send an error response to stdout."""
-        output = {
-            'type': 'error',
-            'payload': {'message': message}
-        }
-        print(json.dumps(output), flush=True)
-
-    def send_command(self, command: str) -> dict:
-        """Send a raw GDB/MI command to GDB."""
-        try:
-            if not self.gdb_controller:
-                error_msg = 'GDB not initialized'
-                self._log_to_file(error_msg, "ERROR")
-                return {'success': False, 'error': error_msg}
-
-            # Ensure command ends with newline
-            if not command.endswith('\n'):
-                command += '\n'
-
-            self._log_to_file(f"Sending GDB command: {command.strip()}", "DEBUG")
-            
-            # Reduced timeout to 8 seconds to work better with TypeScript 15-second timeout
-            try:
-                response = self.gdb_controller.write(command, timeout_sec=8)
-                self._send_response('gdb_response', response)
-                return {'success': True}
-            except Exception as timeout_error:
-                # Handle timeout more gracefully
-                if 'timeout' in str(timeout_error).lower():
-                    error_msg = f"Command failed: Did not get response from gdb after 8 seconds"
-                    self._log_to_file(error_msg, "ERROR")
-                    self._send_error(error_msg)
-                    return {'success': False, 'error': error_msg}
-                else:
-                    raise timeout_error
-
-        except Exception as e:
-            error_msg = f"Failed to send command '{command.strip()}': {str(e)}"
-            self._log_to_file(error_msg, "ERROR")
-            return {'success': False, 'error': str(e)}
-
-    def cleanup(self) -> dict:
-        """Clean up GDB session and resources."""
-        try:
-            self._log_to_file("Starting GDB bridge cleanup")
-            
-            # Signal the reader thread to stop
-            self.running = False
-            
-            # Try to send exit command to GDB first
-            if self.gdb_controller:
-                try:
-                    self._log_to_file("Sending exit command to GDB", "DEBUG")
-                    self.gdb_controller.write('-gdb-exit\n', timeout_sec=5)
-                except Exception as e:
-                    self._log_to_file(f"Failed to send exit command: {e}", "WARNING")
-                    pass  # GDB might already be gone
-
-            # Wait for reader thread to finish
-            # In this case, the reader thread is the GDB controller itself,
-            # so we just wait for the process to exit.
-            if self.gdb_controller:
-                self._log_to_file("Waiting for GDB process to exit", "DEBUG")
-                self.gdb_controller.wait(timeout=2)
-
-            # Terminate GDB process
-            if self.gdb_controller:
-                try:
-                    self._log_to_file("Terminating GDB process", "DEBUG")
-                    self.gdb_controller.terminate()
-                    self.gdb_controller.wait(timeout=3)
-                except Exception as e:
-                    self._log_to_file(f"Failed to terminate GDB process: {e}", "WARNING")
-                    pass
-
-            self._log_to_file("GDB bridge cleanup completed successfully", "SUCCESS")
-            return {'success': True}
-
-        except Exception as e:
-            error_msg = f"Failed to cleanup GDB bridge: {str(e)}"
-            self._log_to_file(error_msg, "ERROR")
-            return {'success': False, 'error': str(e)}
-
-
-def main():
-    parser = argparse.ArgumentParser(description='Enhanced GDB Bridge for Embedder CLI Debugger')
-    parser.add_argument('executable', help='Path to executable to debug')
-    parser.add_argument('--working-dir', help='Working directory for GDB session')
-    parser.add_argument('--remote', '--remote-mode', action='store_true', help='Enable remote debugging mode')
-    parser.add_argument('--host', default='localhost', help='Host for remote debugging (e.g., 192.168.1.100)')
-    parser.add_argument('--port', type=int, default=3333, help='Port for remote debugging')
-    parser.add_argument('--gdb-command', default='gdb', help='Command to run GDB (e.g., gdb, arm-none-eabi-gdb)')
-    
-    args = parser.parse_args()
-    
-    bridge = EmbeddedGDBBridge(args.executable, args.working_dir, args.remote, args.host, args.port, args.gdb_command)
-    
-    # Initialize GDB
-    try:
-        bridge.initialize()
-    except Exception as e:
-        bridge._send_error(f"Failed to initialize bridge: {str(e)}")
-        sys.exit(1)
-    
-    # Command processing loop
-    try:
-        bridge._log_to_file("Starting command processing loop")
-        for line in sys.stdin:
-            try:
-                command_data = json.loads(line.strip())
-                
-                if command_data.get('action') == 'send_command':
-                    raw_command = command_data.get('command', '')
-                    response = bridge.send_command(raw_command)
-                    if not response.get('success'):
-                        error_msg = f"Command failed: {response.get('error', 'Unknown error')}"
-                        bridge._log_to_file(error_msg, "ERROR")
-                        bridge._send_error(error_msg)
-                
-                elif command_data.get('action') == 'cleanup':
-                    bridge._log_to_file("Received cleanup command")
-                    bridge.cleanup()
-                    break
-                
-                else:
-                    error_msg = f"Unknown action: {command_data.get('action')}"
-                    bridge._log_to_file(error_msg, "ERROR")
-                    bridge._send_error(error_msg)
-                    
-            except json.JSONDecodeError as e:
-                error_msg = f"Invalid JSON command: {str(e)}"
-                bridge._log_to_file(error_msg, "ERROR")
-                bridge._send_error(error_msg)
-            except Exception as e:
-                error_msg = f"Command processing error: {str(e)}"
-                bridge._log_to_file(error_msg, "ERROR")
-                bridge._send_error(error_msg)
-                
-    except KeyboardInterrupt:
-        bridge._log_to_file("Received keyboard interrupt, cleaning up", "WARNING")
-        bridge.cleanup()
-    except Exception as e:
-        error_msg = f"Main loop error: {str(e)}"
-        bridge._log_to_file(error_msg, "ERROR")
-        bridge._send_error(error_msg)
-        bridge.cleanup()
-        sys.exit(1)
-
-if __name__ == '__main__':
-    main() 

package/bundle/gdb-debugger-python/requirements.txt

@@ -1 +0,0 @@
-pygdbmi>=0.10.0