Allow code to auto-start once injection is complete when process starts paused

Author: monkeyman192

docs/docs/change_log.rst

@@ -5,7 +5,11 @@ Current (0.1.17.dev)
 --------------------
 
 - Further improved partial structs to allow nesting references to themselves as a type (must be "indirect", ie. the type of a pointer, or dynamic array for example).
-- Added a fallback method to calculate the binary hash in case opening the file fails. Thanks to [@sparrow](https://github.com/samjviana) for implementing this.
+- Added a fallback method to calculate the binary hash in case opening the file fails. Thanks to `@sparrow <https://github.com/samjviana>`_ for implementing this.
+- Fixed some inssues around running python files directly with ``pymhf run``
+- Added the option to pass command line arguments to the function when ``pymhf`` starts the process itself.
+- Added the ``config_overrides`` argument to :py:func:`~pymhf.main.load_mod_file` to allow overriding the static config values.
+- Implemented the functionality so that if ``start_paused`` is True, the program will start automatically once injection is completed (no need for manual input any more).
 
 0.1.16 (16/08/2025)
 -------------------

pymhf/__init__.py

@@ -225,6 +225,8 @@ def run():
     if op.isfile(plugin_name) and op.exists(plugin_name):
         # In this case we are running in stand-alone mode
         standalone = True
+        if plugin_name.endswith(".py"):
+            plugin_name = op.realpath(plugin_name)
 
     if op.isdir(plugin_name) and op.exists(plugin_name):
         # In this case we are running a library directly from pymhf.

pymhf/core/_internal.py

@@ -19,6 +19,7 @@
 MOD_SAVE_DIR: str = ""
 INCLUDED_ASSEMBLIES: dict[str, str] = {}
 CACHE_DIR: str = ""
+_SENTINEL_PTR: int = 0
 
 _executor: ThreadPoolExecutor = None  # type: ignore
 

pymhf/core/_types.py

@@ -21,6 +21,7 @@ class pymhfConfig(TypedDict):
     exe: NotRequired[str]
     pid: NotRequired[int]
     steam_guid: NotRequired[int]
+    args: NotRequired[list[str]]
     required_assemblies: NotRequired[list[str]]
     start_paused: NotRequired[bool]
     default_mod_save_dir: NotRequired[str]

pymhf/core/importing.py

@@ -86,8 +86,9 @@ def import_file(fpath: str) -> Optional[ModuleType]:
             module.__name__ = module_name
             module.__spec__ = spec
             sys.modules[module_name] = module
-            spec.loader.exec_module(module)
-            return module
+            if spec.loader:
+                spec.loader.exec_module(module)
+                return module
         else:
             print("failed")
     except Exception:

pymhf/core/memutils.py

@@ -237,7 +237,7 @@ def pattern_to_bytes(patt: str) -> bytes:
 def _get_binary_info(binary: str) -> Optional[tuple[int, MODULEINFO]]:
     if binary not in cache.hm_cache:
         try:
-            pm_process = pymem.Pymem(_internal.EXE_NAME)
+            pm_process = pymem.Pymem(_internal.EXE_NAME, exact_match=True)
             handle = pm_process.process_handle
             if ((module := cache.module_map.get(binary)) is None) or (handle is None):
                 return None

pymhf/core/process.py

@@ -1,6 +1,7 @@
 import _winapi
 import ctypes
 import ctypes.wintypes
+from subprocess import list2cmdline
 
 kernel32 = ctypes.WinDLL("kernel32.dll")
 
@@ -27,7 +28,7 @@ class SECURITY_ATTRIBUTES(ctypes.Structure):
     ]
 
 
-def start_process(binary_path: str, creationflags: int = 0x0):
+def start_process(args: list[str], creationflags: int = 0x0):
     # Start an executable similarly to subprocess.Popen
     # The functionality here is ripped directly from that implementation,
     # however we don't discard the thread_handle here so that we may use it
@@ -37,14 +38,15 @@ def start_process(binary_path: str, creationflags: int = 0x0):
     thread_attr = SECURITY_ATTRIBUTES()
     thread_attr.bInheritHandle = True
     # Start the process the internal way to get the thread handle.
+    cmd_line = list2cmdline(args)
     handle_process, handle_thread, pid, tid = _winapi.CreateProcess(
         None,
-        binary_path,
+        cmd_line,
         ctypes.byref(proc_attr),
         ctypes.byref(thread_attr),
         False,
         creationflags,
-        None,
+        None,  # type: ignore (it says it wants a dict, but complains if it actually gets one...)
         None,
         None,
     )

pymhf/injected.py

@@ -68,6 +68,13 @@
 
     _internal.LOAD_TYPE = LoadTypeEnum(_internal.LOAD_TYPE)
 
+    # Assign the sentinel and load it from the provided address which is allocated in this process by the
+    # parent process. If the main process isn't actually waiting on this it won't ever be read, but it's
+    # simpler to just allocate it anyway.
+    sentinel = ctypes.c_bool(False)
+    if _internal._SENTINEL_PTR:
+        sentinel = ctypes.c_bool.from_address(_internal._SENTINEL_PTR)
+
     _module_path = _internal.MODULE_PATH
     if op.isfile(_module_path):
         _module_path = op.dirname(_module_path)
@@ -201,7 +208,7 @@ def top_globals(limit: Optional[int] = 10):
 
     executor = ThreadPoolExecutor(2, thread_name_prefix="pyMHF_Internal_Executor")
 
-    binary = pymem.Pymem(_internal.EXE_NAME)
+    binary = pymem.Pymem(_internal.EXE_NAME, exact_match=True)
     cache.module_map = {x.name: x for x in pymem.process.enum_process_module(binary.process_handle)}
 
     # Read the imports
@@ -294,6 +301,11 @@ def top_globals(limit: Optional[int] = 10):
         futures.append(executor.submit(gui.run))
 
     logging.info(f"Serving on executor {server.sockets[0].getsockname()}")
+
+    # Finally, before we run forever, set the sentinel value to True so that if the main process was waiting
+    # for the injected code to complete before starting the process it can now resume it.
+    sentinel.value = True
+
     loop.run_forever()
 
     # Close the server.

pymhf/log_terminal.py

@@ -107,9 +107,8 @@ def serve_until_stopped(self):
             print("Ending logging server...")
 
 
-def main(path: str):
+def main(logdir: str):
     formatter = logging.Formatter("%(asctime)s %(name)-24s %(levelname)-6s %(message)s")
-    logdir = op.join(path, "..", "logs")
     os.makedirs(logdir, exist_ok=True)
     # TODO: Need to make this strip the ANSI escape chars from the written log
     file_handler = logging.FileHandler(