hilda 2.0.16__py3-none-any.whl → 3.0.0__py3-none-any.whl

hilda/hilda_client.py

@@ -5,7 +5,6 @@ import importlib.util
 import json
 import logging
 import os
-import pickle
 import struct
 import sys
 import time
@@ -18,10 +17,9 @@ from functools import cached_property, wraps
 from pathlib import Path
 from typing import Any, Callable, Optional, Union
 
+import click
 import hexdump
 import IPython
-from humanfriendly import prompts
-from humanfriendly.terminal.html import html_to_ansi
 from IPython.core.magic import register_line_magic  # noqa: F401
 from pygments import highlight
 from pygments.formatters import TerminalTrueColorFormatter
@@ -30,11 +28,13 @@ from tqdm import tqdm
 from traitlets.config import Config
 
 from hilda import objective_c_class
+from hilda.breakpoints import BreakpointList, HildaBreakpoint, WhereType
 from hilda.common import CfSerializable, selection_prompt
 from hilda.exceptions import AccessingMemoryError, AccessingRegisterError, AddingLldbSymbolError, \
-    BrokenLocalSymbolsJarError, ConvertingFromNSObjectError, ConvertingToNsObjectError, CreatingObjectiveCSymbolError, \
+    ConvertingFromNSObjectError, ConvertingToNsObjectError, CreatingObjectiveCSymbolError, \
     DisableJetsamMemoryChecksError, EvaluatingExpressionError, HildaException, InvalidThreadIndexError, \
     SymbolAbsentError
+from hilda.ipython_extensions.keybindings import get_keybindings
 from hilda.lldb_importer import lldb
 from hilda.objective_c_symbol import ObjectiveCSymbol
 from hilda.registers import Registers
@@ -50,31 +50,12 @@ except ImportError:
     lldb.KEYSTONE_SUPPORT = False
     print('failed to import keystone. disabling some features')
 
-hilda_art = Path(__file__).resolve().parent.joinpath('hilda_ascii_art.html').read_text()
-
-GREETING = f"""
-{hilda_art}
-
-<b>Hilda has been successfully loaded! 😎
-Usage:
- <span style="color: magenta">p</span>   Global to access all features.
- <span style="color: magenta">F1</span>  Show UI.
- <span style="color: magenta">F2</span>  Toggle enabling of stdout & stderr.
- <span style="color: magenta">F7</span>  Step Into.
- <span style="color: magenta">F8</span>  Step Over.
- <span style="color: magenta">F9</span>  Continue.
- <span style="color: magenta">F10</span> Stop.
-
-Have a nice flight ✈️! Starting an IPython shell...
-"""
-
 
 def disable_logs() -> None:
     logging.getLogger('asyncio').disabled = True
     logging.getLogger('parso.cache').disabled = True
     logging.getLogger('parso.cache.pickle').disabled = True
     logging.getLogger('parso.python.diff').disabled = True
-    logging.getLogger('humanfriendly.prompts').disabled = True
     logging.getLogger('blib2to3.pgen2.driver').disabled = True
     logging.getLogger('hilda.launch_lldb').setLevel(logging.INFO)
 
@@ -82,6 +63,17 @@ def disable_logs() -> None:
 SerializableSymbol = namedtuple('SerializableSymbol', 'address type_ filename')
 
 
+@dataclass
+class HelpSnippet:
+    """ Small snippet line to occur from `HildaClient.show_help()` """
+
+    key: str
+    description: str
+
+    def __str__(self) -> str:
+        return click.style(self.key.ljust(8), bold=True, fg='magenta') + click.style(self.description, bold=True)
+
+
 @dataclass
 class Configs:
     """ Configuration settings for evaluation and monitoring. """
@@ -125,39 +117,17 @@ def stop_is_needed(func: Callable):
     return wrapper
 
 
-class HildaBreakpoint:
-    def __init__(self, hilda_client: 'HildaClient', lldb_breakpoint: lldb.SBBreakpoint,
-                 address: Union[str, int], forced: bool = False, options: Optional[typing.Mapping] = None,
-                 callback: Optional[Callable] = None) -> None:
-        self._hilda_client = hilda_client
-        self.address = address
-        self.forced = forced
-        self.options = options
-        self.callback = callback
-        self.lldb_breakpoint = lldb_breakpoint
-
-    def __repr__(self) -> str:
-        return (f'<{self.__class__.__name__} LLDB:{self.lldb_breakpoint} FORCED:{self.forced} OPTIONS:{self.options} '
-                f'CALLBACK:{self.callback}>')
-
-    def __str__(self) -> str:
-        return repr(self)
-
-    def remove(self) -> None:
-        self._hilda_client.remove_hilda_breakpoint(self.lldb_breakpoint.id)
-
-
 class HildaClient:
     RETVAL_BIT_COUNT = 64
 
-    def __init__(self, debugger: lldb.SBDebugger):
+    def __init__(self, debugger: lldb.SBDebugger) -> None:
         self.logger = logging.getLogger(__name__)
         self.endianness = '<'
         self.debugger = debugger
         self.target = debugger.GetSelectedTarget()
         self.process = self.target.GetProcess()
         self.symbols = SymbolsJar.create(self)
-        self.breakpoints = {}
+        self.breakpoints = BreakpointList(self)
         self.captured_objects = {}
         self.registers = Registers(self)
         self.arch = self.target.GetTriple().split('-')[0]
@@ -177,14 +147,15 @@ class HildaClient:
         self.log_info(f'Target: {self.target}')
         self.log_info(f'Process: {self.process}')
 
-    def hd(self, buf):
+    def hd(self, buf: bytes) -> None:
         """
-        Print an hexdump of given buffer
+        Print hexdump representation for given buffer.
+
         :param buf: buffer to print in hexdump form
         """
-        print(hexdump.hexdump(buf))
+        hexdump.hexdump(buf)
 
-    def lsof(self) -> dict:
+    def lsof(self) -> dict[int, Any]:
         """
         Get dictionary of all open FDs
         :return: Mapping between open FDs and their paths
@@ -201,7 +172,7 @@ class HildaClient:
             if i == depth:
                 break
             row = ''
-            row += html_to_ansi(f'<span style="color: cyan">0x{frame.addr.GetFileAddress():x}</span> ')
+            row += click.style(f'0x{frame.addr.GetFileAddress():x} ', fg='cyan')
             row += str(frame)
             if i == 0:
                 # first line
@@ -222,7 +193,7 @@ class HildaClient:
         if result:
             raise DisableJetsamMemoryChecksError()
 
-    def symbol(self, address):
+    def symbol(self, address: int) -> Symbol:
         """
         Get symbol object for a given address
         :param address:
@@ -230,7 +201,7 @@ class HildaClient:
         """
         return Symbol.create(address, self)
 
-    def objc_symbol(self, address) -> ObjectiveCSymbol:
+    def objc_symbol(self, address: int) -> ObjectiveCSymbol:
         """
         Get objc symbol wrapper for given address
         :param address:
@@ -241,11 +212,12 @@ class HildaClient:
         except HildaException as e:
             raise CreatingObjectiveCSymbolError from e
 
-    def inject(self, filename):
+    def inject(self, filename: str) -> SymbolsJar:
         """
-        Inject a single library into currently running process
-        :param filename:
-        :return: module object
+        Inject a single library into currently running process.
+
+        :param filename: library to inject (dylib)
+        :return: SymbolsJar
         """
         module = self.target.FindModule(lldb.SBFileSpec(os.path.basename(filename), False))
         if module.file.basename is not None:
@@ -459,7 +431,8 @@ class HildaClient:
 
     def set_register(self, name: str, value: Union[float, int]) -> None:
         """
-        Set value for register by its name
+        Set value for register by its name.
+
         :param name: Register name
         :param value: Register value
         """
@@ -473,7 +446,8 @@ class HildaClient:
 
     def objc_call(self, obj: int, selector: str, *params):
         """
-        Simulate a call to an objc selector
+        Simulate a call to an objc selector.
+
         :param obj: obj to pass into `objc_msgSend`
         :param selector: selector to execute
         :param params: any other additional parameters the selector requires
@@ -489,7 +463,7 @@ class HildaClient:
         with self.stopped():
             return self.evaluate_expression(call_expression)
 
-    def call(self, address, argv: list = None):
+    def call(self, address, argv: Optional[list] = None):
         """
         Call function at given address with given parameters
         :param address:
@@ -506,107 +480,11 @@ class HildaClient:
         """
         Monitor every time a given address is called
 
-        The following options are available:
-            regs={reg1: format}
-                will print register values
-
-                Available formats:
-                    x: hex
-                    s: string
-                    cf: use CFCopyDescription() to get more informative description of the object
-                    po: use LLDB po command
-                    std::string: for std::string
-
-                    User defined function, will be called like `format_function(hilda_client, value)`.
-
-                For example:
-                    regs={'x0': 'x'} -> x0 will be printed in HEX format
-            expr={lldb_expression: format}
-                lldb_expression can be for example '$x0' or '$arg1'
-                format behaves just like 'regs' option
-            retval=format
-                Print function's return value. The format is the same as regs format.
-            stop=True
-                force a stop at every hit
-            bt=True
-                print backtrace
-            cmd=[cmd1, cmd2]
-                run several LLDB commands, one by another
-            force_return=value
-                force a return from function with the specified value
-            name=some_value
-                use `some_name` instead of the symbol name automatically extracted from the calling frame
-            override=True
-                override previous break point at same location
-
-
-        :param address:
-        :param condition: set as a conditional breakpoint using an lldb expression
-        :param options:
-        :return:
+        Alias of self.breakpoints.add_monitor()
         """
+        return self.breakpoints.add_monitor(address, condition, **options)
 
-        def callback(hilda, frame, bp_loc, options):
-            """
-            :param HildaClient hilda: Hilda client.
-            :param lldb.SBFrame frame: LLDB Frame object.
-            :param lldb.SBBreakpointLocation bp_loc: LLDB Breakpoint location object.
-            :param dict options: User defined options.
-            """
-            bp = bp_loc.GetBreakpoint()
-
-            symbol = hilda.symbol(hilda.frame.addr.GetLoadAddress(hilda.target))  # type: Symbol
-
-            # by default, attempt to resolve the symbol name through lldb
-            name = str(symbol.lldb_symbol)
-            if options.get('name', False):
-                name = options['name']
-
-            log_message = f'🚨 #{bp.id} 0x{symbol:x} {name} - Thread #{self.thread.idx}:{hex(self.thread.id)}'
-
-            if 'regs' in options:
-                log_message += '\nregs:'
-                for name, fmt in options['regs'].items():
-                    value = hilda.symbol(frame.FindRegister(name).unsigned)
-                    log_message += f'\n\t{name} = {hilda._monitor_format_value(fmt, value)}'
-
-            if 'expr' in options:
-                log_message += '\nexpr:'
-                for name, fmt in options['expr'].items():
-                    value = hilda.symbol(hilda.evaluate_expression(name))
-                    log_message += f'\n\t{name} = {hilda._monitor_format_value(fmt, value)}'
-
-            force_return = options.get('force_return')
-            if force_return is not None:
-                hilda.force_return(force_return)
-                log_message += f'\nforced return: {force_return}'
-
-            if options.get('bt'):
-                # bugfix: for callstacks from xpc events
-                hilda.finish()
-                for frame in hilda.bt():
-                    log_message += f'\n\t{frame[0]} {frame[1]}'
-
-            retval = options.get('retval')
-            if retval is not None:
-                # return from function
-                hilda.finish()
-                value = hilda.evaluate_expression('$arg1')
-                log_message += f'\nreturned: {hilda._monitor_format_value(retval, value)}'
-
-            hilda.log_info(log_message)
-
-            for cmd in options.get('cmd', []):
-                hilda.lldb_handle_command(cmd)
-
-            if options.get('stop', False):
-                hilda.log_info('Process remains stopped and focused on current thread')
-            else:
-                hilda.cont()
-
-        return self.bp(address, callback, condition=condition, **options)
-
-    def show_current_source(self):
+    def show_current_source(self) -> None:
         """ print current source code if possible """
         self.lldb_handle_command('f')
 
@@ -632,26 +510,7 @@ class HildaClient:
         if self.ui_manager.active:
             self.ui_manager.show()
 
-    def remove_all_hilda_breakpoints(self, remove_forced=False):
-        """
-        Remove all breakpoints created by Hilda
-        :param remove_forced: include removed of "forced" breakpoints
-        """
-        breakpoints = list(self.breakpoints.items())
-        for bp_id, bp in breakpoints:
-            if remove_forced or not bp.forced:
-                self.remove_hilda_breakpoint(bp_id)
-
-    def remove_hilda_breakpoint(self, bp_id: int) -> None:
-        """
-        Remove a single breakpoint placed by Hilda
-        :param bp_id: Breakpoint's ID
-        """
-        self.target.BreakpointDelete(bp_id)
-        del self.breakpoints[bp_id]
-        self.log_info(f'BP #{bp_id} has been removed')
-
-    def force_return(self, value=0):
+    def force_return(self, value: int = 0) -> None:
         """
         Prematurely return from a stack frame, short-circuiting exection of newer frames and optionally
         yielding a specified value.
@@ -661,11 +520,11 @@ class HildaClient:
         self.finish()
         self.set_register('x0', value)
 
-    def proc_info(self):
+    def proc_info(self) -> None:
         """ Print information about currently running mapped process. """
         print(self.process)
 
-    def print_proc_entitlements(self):
+    def print_proc_entitlements(self) -> None:
         """ Get the plist embedded inside the process' __LINKEDIT section. """
         linkedit_section = self.target.modules[0].FindSection('__LINKEDIT')
         linkedit_data = self.symbol(linkedit_section.GetLoadAddress(self.target)).peek(linkedit_section.size)
@@ -675,112 +534,24 @@ class HildaClient:
         entitlements = str(linkedit_data[linkedit_data.find(b'<?xml'):].split(b'\xfa', 1)[0], 'utf8')
         print(highlight(entitlements, XmlLexer(), TerminalTrueColorFormatter()))
 
-    def bp(self, address_or_name: Union[int, str], callback: Optional[Callable] = None, condition: str = None,
-           forced=False, module_name: Optional[str] = None, **options) -> HildaBreakpoint:
+    def bp(self, address_or_name: WhereType, callback: Optional[Callable] = None, condition: Optional[str] = None,
+           guarded: bool = False, description: Optional[str] = None, **options) -> HildaBreakpoint:
         """
         Add a breakpoint
-        :param address_or_name:
+
+        Alias of self.breakpoints.add()
+
+        :param address_or_name: Where to place the breakpoint
         :param condition: set as a conditional breakpoint using lldb expression
         :param callback: callback(hilda, *args) to be called
-        :param forced: whether the breakpoint should be protected frm usual removal.
-        :param module_name: Specify module name to place the BP in (used with `address_or_name` when using a name)
+        :param guarded: whether the breakpoint should be protected frm usual removal.
+        :param description: Attach a breakpoint description
         :param options: can contain an `override` keyword to specify if to override an existing BP
         :return: native LLDB breakpoint
         """
-        if address_or_name in [bp.address for bp in self.breakpoints.values()]:
-            override = True if options.get('override', True) else False
-            if override or prompts.prompt_for_confirmation('A breakpoint already exist in given location. '
-                                                           'Would you like to delete the previous one?', True):
-                breakpoints = list(self.breakpoints.items())
-                for bp_id, bp in breakpoints:
-                    if address_or_name == bp.address:
-                        self.remove_hilda_breakpoint(bp_id)
-
-        if isinstance(address_or_name, int):
-            bp = self.target.BreakpointCreateByAddress(address_or_name)
-        elif isinstance(address_or_name, str):
-            bp = self.target.BreakpointCreateByName(address_or_name)
-
-        if condition is not None:
-            bp.SetCondition(condition)
-
-        # add into Hilda's internal list of breakpoints
-        self.breakpoints[bp.id] = HildaBreakpoint(self, bp, address=address_or_name, forced=forced, options=options,
-                                                  callback=callback)
-
-        if callback is not None:
-            bp.SetScriptCallbackFunction('lldb.hilda_client.bp_callback_router')
-
-        self.log_info(f'Breakpoint #{bp.id} has been set')
-        return self.breakpoints[bp.id]
-
-    def bp_callback_router(self, frame, bp_loc, *_):
-        """
-        Route the breakpoint callback the specific breakpoint callback.
-        :param lldb.SBFrame frame: LLDB Frame object.
-        :param lldb.SBBreakpointLocation bp_loc: LLDB Breakpoint location object.
-        """
-        bp_id = bp_loc.GetBreakpoint().GetID()
-        self._bp_frame = frame
-        try:
-            self.breakpoints[bp_id].callback(self, frame, bp_loc, self.breakpoints[bp_id].options)
-        finally:
-            self._bp_frame = None
-
-    def show_hilda_breakpoints(self):
-        """ Show existing breakpoints created by Hilda. """
-        for bp_id, bp in self.breakpoints.items():
-            print(f'🚨 Breakpoint #{bp_id}: Forced: {bp.forced}')
-            if isinstance(bp.address, int):
-                print(f'\tAddress: 0x{bp.address:x}')
-            elif isinstance(bp.address, str):
-                print(f'\tName: {bp.address}')
-            print(f'\tOptions: {bp.options}')
-
-    def save(self, filename=None):
-        """
-        Save loaded symbols map (for loading later using the load() command)
-        :param filename: optional filename for where to store
-        """
-        if filename is None:
-            filename = self._get_saved_state_filename()
-
-        self.log_info(f'saving current state info: {filename}')
-        with open(filename, 'wb') as f:
-            symbols_copy = {}
-            for k, v in self.symbols.items():
-                # converting the symbols into serializable objects
-                symbols_copy[k] = SerializableSymbol(address=int(v),
-                                                     type_=v.type_,
-                                                     filename=v.filename)
-            pickle.dump(symbols_copy, f)
+        return self.breakpoints.add(address_or_name, callback, condition, guarded, description=description, **options)
 
-    def load(self, filename=None):
-        """
-        Load an existing symbols map (previously saved by the save() command)
-        :param filename: filename to load from
-        """
-        if filename is None:
-            filename = self._get_saved_state_filename()
-
-        self.log_info(f'loading current state from: {filename}')
-        with open(filename, 'rb') as f:
-            symbols_copy = pickle.load(f)
-
-            for k, v in tqdm(symbols_copy.items()):
-                self.symbols[k] = self.symbol(v.address)
-
-            # perform sanity test for symbol rand
-            if self.symbols.rand() == 0 and self.symbols.rand() == 0:
-                # rand returning 0 twice means the loaded file is probably outdated
-                raise BrokenLocalSymbolsJarError()
-
-            # assuming the first main image will always change
-            self.rebind_symbols(image_range=[0, 0])
-            self.init_dynamic_environment()
-            self._symbols_loaded = True
-
-    def po(self, expression, cast=None):
+    def po(self, expression: str, cast: Optional[str] = None) -> str:
         """
         Print given object using LLDB's po command
 
@@ -804,7 +575,7 @@ class HildaClient:
             raise EvaluatingExpressionError(res.GetError())
         return res.GetOutput().strip()
 
-    def globalize_symbols(self):
+    def globalize_symbols(self) -> None:
         """
         Make all symbols in python's global scope
         """
@@ -817,18 +588,18 @@ class HildaClient:
                     and '.' not in name:
                 self._add_global(name, value, reserved_names)
 
-    def jump(self, symbol: int):
+    def jump(self, symbol: int) -> None:
         """ jump to given symbol """
         self.lldb_handle_command(f'j *{symbol}')
 
-    def lldb_handle_command(self, cmd):
+    def lldb_handle_command(self, cmd: str) -> None:
         """
         Execute an LLDB command
 
         For example:
             lldb_handle_command('register read')
 
-        :param cmd:
+        :param cmd: LLDB command
         """
         self.debugger.HandleCommand(cmd)
 
@@ -968,7 +739,7 @@ class HildaClient:
         return self.thread.GetSelectedFrame()
 
     @contextmanager
-    def stopped(self, interval=0):
+    def stopped(self, interval: int = 0):
         """
         Context-Manager for execution while process is stopped.
         If interval is supplied, then if the device is in running state, it will sleep for the interval
@@ -988,7 +759,7 @@ class HildaClient:
                 self.cont()
 
     @contextmanager
-    def safe_malloc(self, size):
+    def safe_malloc(self, size: int):
         """
         Context-Manager for allocating a block of memory which is freed afterwards
         :param size:
@@ -1097,19 +868,36 @@ class HildaClient:
                 return
             client.finish()
             client.log_info(f'Desired module has been loaded: {expression}. Process remains stopped')
-            bp = bp_loc.GetBreakpoint()
-            client.remove_hilda_breakpoint(bp.id)
+            bp_id = bp_loc.GetBreakpoint().GetID()
+            client.breakpoints.remove(bp_id)
 
         self.bp('dlopen', bp)
         self.cont()
 
+    def show_help(self, *_) -> None:
+        """
+        Show banner help message
+        """
+        help_snippets = [HelpSnippet(key='p', description='Global to access all features')]
+        for keybinding in get_keybindings(self):
+            help_snippets.append(HelpSnippet(key=keybinding.key.upper(), description=keybinding.description))
+
+        for help_snippet in help_snippets:
+            click.echo(help_snippet)
+
     def interact(self, additional_namespace: Optional[typing.Mapping] = None,
                  startup_files: Optional[list[str]] = None) -> None:
         """ Start an interactive Hilda shell """
         if not self._dynamic_env_loaded:
             self.init_dynamic_environment()
-        print('\n')
-        self.log_info(html_to_ansi(GREETING))
+
+        # Show greeting
+        click.secho('Hilda has been successfully loaded! 😎', bold=True)
+        click.secho('Usage:', bold=True)
+        self.show_help()
+        click.echo(click.style('Have a nice flight ✈️! Starting an IPython shell...', bold=True))
+
+        # Configure and start IPython shell
         ipython_config = Config()
         ipython_config.IPCompleter.use_jedi = True
         ipython_config.BaseIPythonApplication.profile = 'hilda'
@@ -1215,21 +1003,6 @@ class HildaClient:
         else:
             return value[0].peek_str()
 
-    def _monitor_format_value(self, fmt, value):
-        if callable(fmt):
-            return fmt(self, value)
-        formatters = {
-            'x': lambda val: f'0x{int(val):x}',
-            's': lambda val: val.peek_str() if val else None,
-            'cf': lambda val: val.cf_description,
-            'po': lambda val: val.po(),
-            'std::string': self._std_string
-        }
-        if fmt in formatters:
-            return formatters[fmt](value)
-        else:
-            return f'{value:x} (unsupported format)'
-
     @cached_property
     def _object_identifier(self) -> Symbol:
         return self.symbols.objc_getClass('VMUObjectIdentifier').objc_call('alloc').objc_call(

hilda/ipython_extensions/keybindings.py

@@ -1,24 +1,47 @@
+from dataclasses import dataclass
+from typing import Callable
+
 from prompt_toolkit.enums import DEFAULT_BUFFER
 from prompt_toolkit.filters import EmacsInsertMode, HasFocus, HasSelection, ViInsertMode
 from prompt_toolkit.keys import Keys
 
 
+@dataclass
+class Keybinding:
+    key: str
+    description: str
+    callback: Callable
+
+
+def get_keybindings(hilda_client) -> list[Keybinding]:
+    """
+    Get list of keybindings
+
+    :param hilda.hilda_client.HildaClient hilda_client: Hilda client to bind the keys to operations
+    """
+    return [
+        Keybinding(key=Keys.F1, description='Show this help', callback=hilda_client.show_help),
+        Keybinding(key=Keys.F2, description='Show process state UI', callback=hilda_client.ui_manager.show),
+        Keybinding(key=Keys.F3, description='Toggle enabling of stdout & stderr',
+                   callback=hilda_client.toggle_enable_stdout_stderr),
+        Keybinding(key=Keys.F7, description='Step Into', callback=hilda_client.step_into),
+        Keybinding(key=Keys.F8, description='Step Over', callback=hilda_client.step_over),
+        Keybinding(key=Keys.F9, description='Continue',
+                   callback=lambda _: (hilda_client.log_info('Sending continue'), hilda_client.cont())),
+        Keybinding(key=Keys.F10, description='Stop',
+                   callback=lambda _: (hilda_client.log_info('Sending stop'), hilda_client.stop())),
+    ]
+
+
 def load_ipython_extension(ipython):
     def register_keybindings():
-        hilda = ipython.user_ns['p']
-        keys_mapping = {Keys.F1: hilda.ui_manager.show,
-                        Keys.F2: hilda.toggle_enable_stdout_stderr,
-                        Keys.F7: hilda.step_into,
-                        Keys.F8: hilda.step_over,
-                        Keys.F9: lambda _: (hilda.log_info('Sending continue'), hilda.cont()),
-                        Keys.F10: lambda _: (hilda.log_info('Sending stop'), hilda.stop())}
-
+        hilda_client = ipython.user_ns['p']
         insert_mode = ViInsertMode() | EmacsInsertMode()
         registry = ipython.pt_app.key_bindings
 
-        for key, callback in keys_mapping.items():
-            registry.add_binding(key, filter=(HasFocus(DEFAULT_BUFFER) & ~HasSelection() & insert_mode))(
-                callback)
+        for keybind in get_keybindings(hilda_client):
+            registry.add_binding(
+                keybind.key, filter=(HasFocus(DEFAULT_BUFFER) & ~HasSelection() & insert_mode))(keybind.callback)
 
     register_keybindings()
     ipython.events.register('shell_initialized', register_keybindings)

hilda/objective_c_class.py

@@ -4,7 +4,6 @@ from collections import namedtuple
 from dataclasses import dataclass, field
 from functools import partial
 from typing import Any
-from uuid import uuid4
 
 from objc_types_decoder.decode import decode as decode_type
 from objc_types_decoder.decode import decode_with_tail
@@ -188,19 +187,16 @@ class Class:
             hilda.log_info('removing breakpoints')
             for bp_id, bp in list(hilda.breakpoints.items()):
                 if 'group_uuid' in bp.options and bp.options.get('group_uuid', '') == options['group_uuid']:
-                    hilda.remove_hilda_breakpoint(bp_id)
+                    hilda.breakpoints.remove(bp_id)
             captured = hilda.evaluate_expression('$arg1')
             captured = captured.objc_symbol
             hilda.captured_objects[options['name'].split(' ')[0].split('[')[1]] = captured
             hilda.cont()
 
-        group_uuid = str(uuid4())
-
         for method in self.methods:
             if not method.is_class:
                 # only instance methods are relevant for capturing self
-                method.imp.bp(hook, group_uuid=group_uuid,
-                              name=f'-[{class_name} {method.name}]')
+                method.imp.bp(hook)
 
         if sync:
             self._client.cont()