hypha-debugger 0.1.6__tar.gz → 0.1.7__tar.gz

{hypha_debugger-0.1.6 → hypha_debugger-0.1.7}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypha-debugger
-Version: 0.1.6
+Version: 0.1.7
 Summary: Injectable debugger for Python processes and AI agents, powered by Hypha RPC
 Author: Amun AI AB
 License: MIT

{hypha_debugger-0.1.6 → hypha_debugger-0.1.7}/hypha_debugger/__init__.py

@@ -12,5 +12,5 @@ Usage (sync):
 
 from hypha_debugger.debugger import start_debugger, start_debugger_sync, DebugSession
 
-__version__ = "0.1.6"
+__version__ = "0.1.7"
 __all__ = ["start_debugger", "start_debugger_sync", "DebugSession", "__version__"]

{hypha_debugger-0.1.6 → hypha_debugger-0.1.7}/hypha_debugger/debugger.py

@@ -60,7 +60,7 @@ def _build_instruction_block(service_url: str, token: str = "") -> str:
         "#",
         "# Available functions:",
         "#   get_process_info    - PID, Python version, CWD, platform, memory",
-        "#   execute_code        - Run arbitrary Python code (with timeout)",
+        "#   execute_code        - Run Python code (persistent REPL, auto-captures last expr)",
         "#   get_variable        - Inspect a variable by name",
         "#   list_variables      - List variables in a namespace",
         "#   get_stack_trace     - Stack traces of all threads",

hypha_debugger-0.1.7/hypha_debugger/services/execute.py

@@ -0,0 +1,191 @@
+"""Arbitrary code execution service with persistent REPL and timeout support."""
+
+import ast
+import io
+import json
+import reprlib
+import signal
+import sys
+import threading
+import traceback
+from contextlib import redirect_stdout, redirect_stderr
+from typing import Any, Dict, Optional
+
+# Default timeout for code execution (seconds). 0 = no timeout.
+DEFAULT_TIMEOUT = 30
+
+# Persistent REPL namespace — survives across calls.
+_repl_globals: Dict[str, Any] = {
+    "__name__": "__repl__",
+    "__builtins__": __builtins__,
+}
+
+
+def _safe_jsonable(obj: Any) -> Any:
+    """Return obj if it's JSON-serializable, else its repr."""
+    try:
+        json.dumps(obj)
+        return obj
+    except Exception:
+        return reprlib.repr(obj)
+
+
+def _summarize_namespace(ns: Dict[str, Any]) -> Dict[str, Dict[str, Any]]:
+    """Summarize namespace variables (skip dunders)."""
+    summary = {}
+    for k, v in ns.items():
+        if k.startswith("__") and k.endswith("__"):
+            continue
+        summary[k] = {
+            "type": type(v).__name__,
+            "repr": reprlib.repr(v),
+            "jsonable": _safe_jsonable(v),
+        }
+    return summary
+
+
+try:
+    from pydantic import Field
+    from hypha_rpc.utils.schema import schema_function
+
+    @schema_function
+    def execute_code(
+        code: str = Field(..., description="Python code to execute."),
+        namespace: str = Field(
+            default="",
+            description=(
+                'Namespace to execute in. Default: "" uses the persistent REPL namespace '
+                '(variables survive across calls). Use "__main__" for the main module namespace.'
+            ),
+        ),
+        timeout: int = Field(
+            default=DEFAULT_TIMEOUT,
+            description="Timeout in seconds. 0 for no timeout. Default: 30.",
+        ),
+    ) -> dict:
+        """Execute Python code in the debugger process and return stdout, stderr, and the result.
+
+        Uses AST parsing to capture the last expression's value automatically.
+        For example, `x = 1\\nx + 1` will return result=2.
+        Code runs in a persistent REPL namespace so variables, functions, and imports
+        survive across calls. A timeout (default 30s) prevents infinite loops.
+        """
+        return _execute_impl(code, namespace, timeout)
+
+except ImportError:
+
+    def execute_code(code: str, namespace: str = "", timeout: int = DEFAULT_TIMEOUT) -> dict:
+        """Execute Python code in the debugger process."""
+        return _execute_impl(code, namespace, timeout)
+
+
+def _get_namespace(namespace: str) -> Dict[str, Any]:
+    """Get the target namespace dict."""
+    if not namespace:
+        return _repl_globals
+    if namespace == "__main__":
+        mod = sys.modules.get("__main__")
+        return vars(mod) if mod else _repl_globals
+    mod = sys.modules.get(namespace)
+    return vars(mod) if mod else _repl_globals
+
+
+def _execute_impl(code: str, namespace: str = "", timeout: int = DEFAULT_TIMEOUT) -> dict:
+    """Implementation of code execution with AST-based last-expression capture."""
+    ns = _get_namespace(namespace)
+
+    # Parse the code into an AST
+    try:
+        tree = ast.parse(code, mode="exec")
+    except SyntaxError as e:
+        return {
+            "ok": False,
+            "stdout": "",
+            "stderr": "",
+            "result": None,
+            "result_repr": None,
+            "error_type": type(e).__name__,
+            "error_message": str(e),
+            "traceback": traceback.format_exc(),
+        }
+
+    # Separate the last expression (if any) so we can eval it for its value
+    body = tree.body
+    last_expr_node = None
+    if body and isinstance(body[-1], ast.Expr):
+        last_expr_node = body[-1].value
+        body = body[:-1]
+
+    exec_code = compile(
+        ast.Module(body=body, type_ignores=[]),
+        filename="<debugger-repl>",
+        mode="exec",
+    )
+
+    eval_code = None
+    if last_expr_node is not None:
+        eval_code = compile(
+            ast.Expression(last_expr_node),
+            filename="<debugger-repl>",
+            mode="eval",
+        )
+
+    stdout_buf = io.StringIO()
+    stderr_buf = io.StringIO()
+    result = None
+    error_type = None
+    error_message = None
+    error_tb = None
+    timed_out = False
+
+    def _run():
+        nonlocal result
+        with redirect_stdout(stdout_buf), redirect_stderr(stderr_buf):
+            exec(exec_code, ns, ns)
+            if eval_code is not None:
+                result = eval(eval_code, ns, ns)
+
+    try:
+        if timeout > 0 and threading.current_thread() is threading.main_thread():
+            def _timeout_handler(signum, frame):
+                raise TimeoutError(f"Code execution timed out after {timeout}s")
+
+            old_handler = signal.signal(signal.SIGALRM, _timeout_handler)
+            signal.alarm(timeout)
+            try:
+                _run()
+            except TimeoutError as e:
+                error_type = "TimeoutError"
+                error_message = str(e)
+                error_tb = traceback.format_exc()
+                timed_out = True
+            finally:
+                signal.alarm(0)
+                signal.signal(signal.SIGALRM, old_handler)
+        else:
+            _run()
+    except Exception as e:
+        error_type = type(e).__name__
+        error_message = str(e)
+        error_tb = traceback.format_exc()
+
+    response = {
+        "ok": error_type is None,
+        "stdout": stdout_buf.getvalue(),
+        "stderr": stderr_buf.getvalue(),
+        "result": _safe_jsonable(result),
+        "result_repr": reprlib.repr(result) if result is not None else None,
+        "result_type": type(result).__name__ if result is not None else "None",
+    }
+
+    if error_type:
+        response["error_type"] = error_type
+        response["error_message"] = error_message
+        response["traceback"] = error_tb
+        # Keep backward-compat "error" key
+        response["error"] = error_tb or error_message
+
+    if timed_out:
+        response["timed_out"] = True
+
+    return response

{hypha_debugger-0.1.6 → hypha_debugger-0.1.7}/hypha_debugger/services/source.py

@@ -98,12 +98,15 @@ Get information about the current Python process.
 - **Example**: `curl "$SERVICE_URL/get_process_info"`
 
 ### execute_code(code, namespace?, timeout?)
-Execute arbitrary Python code in the process.
+Execute arbitrary Python code in the process. Uses AST parsing to automatically
+capture the last expression's value. Variables, functions, and imports persist
+across calls in the default REPL namespace.
 - **code** (string, required): Python code to execute.
-- **namespace** (string, default `"__main__"`): Module namespace to execute in.
+- **namespace** (string, default `""`): Namespace. Empty = persistent REPL. `"__main__"` = main module.
 - **timeout** (int, default `30`): Timeout in seconds. 0 for no timeout.
-- **Returns**: `{stdout, stderr, result, result_type, error?, timed_out?}`
-- Tries `eval()` first (returns value), falls back to `exec()` (returns None).
+- **Returns**: `{ok, stdout, stderr, result, result_repr, result_type, error?, error_type?, error_message?, traceback?, timed_out?}`
+- The last expression in the code block is automatically captured as `result`.
+  E.g. `"x = 1\\nx + 1"` returns `result=2`.
 - **Example**:
   ```bash
   curl -X POST "$SERVICE_URL/execute_code" \\

{hypha_debugger-0.1.6 → hypha_debugger-0.1.7}/hypha_debugger.egg-info/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypha-debugger
-Version: 0.1.6
+Version: 0.1.7
 Summary: Injectable debugger for Python processes and AI agents, powered by Hypha RPC
 Author: Amun AI AB
 License: MIT

{hypha_debugger-0.1.6 → hypha_debugger-0.1.7}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hypha-debugger"
-version = "0.1.6"
+version = "0.1.7"
 description = "Injectable debugger for Python processes and AI agents, powered by Hypha RPC"
 readme = "README.md"
 license = {text = "MIT"}

{hypha_debugger-0.1.6 → hypha_debugger-0.1.7}/tests/test_services.py

@@ -38,6 +38,7 @@ def test_get_installed_packages_filter():
 
 def test_execute_code_expression():
     result = execute_code("1 + 2")
+    assert result["ok"] is True
     assert result["result"] == 3
     assert result["result_type"] == "int"
     assert result.get("error") is None
@@ -45,48 +46,87 @@ def test_execute_code_expression():
 
 def test_execute_code_statement():
     result = execute_code("x = 42\nprint(x)")
+    assert result["ok"] is True
     assert "42" in result["stdout"]
     assert result.get("error") is None
 
 
 def test_execute_code_error():
     result = execute_code("1 / 0")
+    assert result["ok"] is False
     assert "error" in result
     assert "ZeroDivisionError" in result["error"]
+    assert result["error_type"] == "ZeroDivisionError"
+
+
+def test_execute_code_syntax_error():
+    result = execute_code("def")
+    assert result["ok"] is False
+    assert result["error_type"] == "SyntaxError"
 
 
 def test_execute_code_import():
-    # Multi-statement uses exec (no return value), so test via stdout
     result = execute_code("import json; print(json.dumps({'a': 1}))")
     assert '{"a": 1}' in result["stdout"]
     assert result.get("error") is None
 
 
 def test_execute_code_multiline():
+    """AST parsing captures the last expression's value."""
     code = """
 def greet(name):
     return f"Hello, {name}!"
 greet("World")
 """
     result = execute_code(code)
-    assert result.get("error") is None
-    # eval/exec may or may not capture the last expression depending on implementation
-    # but at least no error
+    assert result["ok"] is True
+    assert result["result"] == "Hello, World!"
+
+
+def test_execute_code_multiline_no_trailing_expr():
+    """Multi-statement code with no trailing expression returns None."""
+    code = "a = 1\nb = 2"
+    result = execute_code(code)
+    assert result["ok"] is True
+    assert result["result"] is None
+
+
+def test_execute_code_persistent_namespace():
+    """Variables persist across calls in the default REPL namespace."""
+    execute_code("repl_test_var = 42")
+    result = execute_code("repl_test_var + 8")
+    assert result["ok"] is True
+    assert result["result"] == 50
 
 
 def test_execute_code_timeout():
     """Test that timeout parameter works (execution should not hang)."""
     result = execute_code("'done'", timeout=5)
+    assert result["ok"] is True
     assert result["result"] == "done"
     assert result.get("error") is None
 
 
 def test_execute_code_stdout_capture():
     result = execute_code("print('hello'); print('world')")
+    assert result["ok"] is True
     assert "hello" in result["stdout"]
     assert "world" in result["stdout"]
 
 
+def test_execute_code_stderr_capture():
+    result = execute_code("import sys; print('err', file=sys.stderr)")
+    assert result["ok"] is True
+    assert "err" in result["stderr"]
+
+
+def test_execute_code_result_repr():
+    result = execute_code("[1, 2, 3]")
+    assert result["ok"] is True
+    assert result["result"] == [1, 2, 3]
+    assert result["result_repr"] is not None
+
+
 # --- inspect_vars ---
 
 def test_get_variable():

hypha_debugger-0.1.6/hypha_debugger/services/execute.py

@@ -1,142 +0,0 @@
-"""Arbitrary code execution service with timeout support."""
-
-import sys
-import io
-import signal
-import traceback
-import threading
-
-# Default timeout for code execution (seconds). 0 = no timeout.
-DEFAULT_TIMEOUT = 30
-
-try:
-    from pydantic import Field
-    from hypha_rpc.utils.schema import schema_function
-
-    @schema_function
-    def execute_code(
-        code: str = Field(..., description="Python code to execute."),
-        namespace: str = Field(
-            default="__main__",
-            description='Namespace to execute in. Default: "__main__" (the main module namespace).',
-        ),
-        timeout: int = Field(
-            default=DEFAULT_TIMEOUT,
-            description="Timeout in seconds. 0 for no timeout. Default: 30.",
-        ),
-    ) -> dict:
-        """Execute Python code in the debugger process and return stdout, stderr, and the result.
-
-        Supports both expressions (returns the value) and statements.
-        Code runs in the target namespace so you can define functions, import modules, etc.
-        A timeout (default 30s) prevents infinite loops from hanging the debugger.
-        """
-        return _execute_impl(code, namespace, timeout)
-
-except ImportError:
-
-    def execute_code(code: str, namespace: str = "__main__", timeout: int = DEFAULT_TIMEOUT) -> dict:
-        """Execute Python code in the debugger process."""
-        return _execute_impl(code, namespace, timeout)
-
-
-def _execute_impl(code: str, namespace: str = "__main__", timeout: int = DEFAULT_TIMEOUT) -> dict:
-    """Implementation of code execution with optional timeout."""
-    # Get the target namespace
-    if namespace == "__main__":
-        ns = vars(sys.modules.get("__main__", {}))
-    else:
-        mod = sys.modules.get(namespace)
-        ns = vars(mod) if mod else {}
-
-    stdout_capture = io.StringIO()
-    stderr_capture = io.StringIO()
-    old_stdout = sys.stdout
-    old_stderr = sys.stderr
-
-    result = None
-    error = None
-    timed_out = False
-
-    try:
-        sys.stdout = stdout_capture
-        sys.stderr = stderr_capture
-
-        if timeout > 0 and threading.current_thread() is threading.main_thread():
-            # Use SIGALRM for timeout on the main thread (Unix only)
-            def _timeout_handler(signum, frame):
-                raise TimeoutError(f"Code execution timed out after {timeout}s")
-
-            old_handler = signal.signal(signal.SIGALRM, _timeout_handler)
-            signal.alarm(timeout)
-            try:
-                result = _run_code(code, ns)
-            except TimeoutError as e:
-                error = str(e)
-                timed_out = True
-            finally:
-                signal.alarm(0)
-                signal.signal(signal.SIGALRM, old_handler)
-        else:
-            # No timeout or not on main thread — run directly
-            result = _run_code(code, ns)
-    except Exception:
-        error = traceback.format_exc()
-    finally:
-        sys.stdout = old_stdout
-        sys.stderr = old_stderr
-
-    stdout_str = stdout_capture.getvalue()
-    stderr_str = stderr_capture.getvalue()
-
-    # Serialize result safely
-    serialized_result = _safe_serialize(result)
-
-    response = {
-        "stdout": stdout_str,
-        "stderr": stderr_str,
-        "result": serialized_result,
-        "result_type": type(result).__name__ if result is not None else "None",
-    }
-    if error:
-        response["error"] = error
-    if timed_out:
-        response["timed_out"] = True
-
-    return response
-
-
-def _run_code(code: str, ns: dict):
-    """Try as expression first (to capture return value), fall back to exec."""
-    try:
-        return eval(code, ns)
-    except SyntaxError:
-        exec(code, ns)
-        return None
-
-
-def _safe_serialize(obj, depth=0, max_depth=3):
-    """Safely serialize an object for RPC transport."""
-    if depth > max_depth:
-        return repr(obj)
-    if obj is None:
-        return None
-    if isinstance(obj, (str, int, float, bool)):
-        return obj
-    if isinstance(obj, bytes):
-        return f"<bytes len={len(obj)}>"
-    if isinstance(obj, (list, tuple)):
-        return [_safe_serialize(v, depth + 1, max_depth) for v in obj[:100]]
-    if isinstance(obj, dict):
-        return {
-            str(k): _safe_serialize(v, depth + 1, max_depth)
-            for k, v in list(obj.items())[:50]
-        }
-    if isinstance(obj, set):
-        return [_safe_serialize(v, depth + 1, max_depth) for v in list(obj)[:100]]
-    # Try repr for everything else
-    try:
-        r = repr(obj)
-        return r if len(r) < 1000 else r[:1000] + "..."
-    except Exception:
-        return f"<{type(obj).__name__}>"