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

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

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: hypha-debugger
-Version: 0.1.5
+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.5 → 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.5"
+__version__ = "0.1.7"
 __all__ = ["start_debugger", "start_debugger_sync", "DebugSession", "__version__"]

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

@@ -15,6 +15,7 @@ from hypha_debugger.services.inspect_vars import (
     get_stack_trace,
 )
 from hypha_debugger.services.filesystem import list_files, read_file, write_file
+from hypha_debugger.services.source import get_source, get_skill_md
 
 logger = logging.getLogger("hypha_debugger")
 
@@ -59,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",
@@ -67,6 +68,8 @@ def _build_instruction_block(service_url: str, token: str = "") -> str:
         "#   read_file           - Read file content (with offset/limit)",
         "#   write_file          - Write/append to a file",
         "#   get_installed_packages - List pip packages",
+        "#   get_source           - Get debugger source code (for self-inspection)",
+        "#   get_skill_md         - Get full API docs as Markdown",
         "#",
         "# POST endpoints accept JSON body with parameter names as keys.",
         "",
@@ -96,6 +99,9 @@ def _build_instruction_block(service_url: str, token: str = "") -> str:
         f'curl -X POST "$SERVICE_URL/read_file"{auth}'
         ' -H "Content-Type: application/json"'
         " -d '{\"path\": \"hello.txt\"}'",
+        "",
+        "# Get full API documentation:",
+        f'curl "$SERVICE_URL/get_skill_md"{auth}',
     ]
     return "\n".join(lines)
 
@@ -272,6 +278,8 @@ async def start_debugger(
         "list_files": list_files,
         "read_file": read_file,
         "write_file": write_file,
+        "get_source": get_source,
+        "get_skill_md": get_skill_md,
     }
 
     svc_info = await server.register_service(service)
@@ -353,6 +361,8 @@ def start_debugger_sync(
         "list_files": list_files,
         "read_file": read_file,
         "write_file": write_file,
+        "get_source": get_source,
+        "get_skill_md": get_skill_md,
     }
 
     svc_info = server.register_service(service)

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.7/hypha_debugger/services/source.py

@@ -0,0 +1,190 @@
+"""Source code and skill documentation service."""
+
+import inspect
+import os
+
+try:
+    from pydantic import Field
+    from hypha_rpc.utils.schema import schema_function
+
+    @schema_function
+    def get_source(
+        module: str = Field(
+            default="",
+            description=(
+                'Module path relative to hypha_debugger, e.g. "services.execute". '
+                'Empty string returns a list of available modules.'
+            ),
+        ),
+    ) -> dict:
+        """Get the source code of hypha-debugger modules.
+
+        Use this to understand exactly what functions are available, their
+        parameters, and how they work. Pass an empty string to list modules.
+        """
+        return _get_source_impl(module)
+
+    @schema_function
+    def get_skill_md() -> str:
+        """Get full API documentation for all debugger service functions.
+
+        Returns a Markdown document describing every available function,
+        its parameters, return values, and curl usage examples. Suitable
+        for pasting into an AI agent context.
+        """
+        return _get_skill_md_impl()
+
+except ImportError:
+
+    def get_source(module: str = "") -> dict:
+        """Get the source code of hypha-debugger modules."""
+        return _get_source_impl(module)
+
+    def get_skill_md() -> str:
+        """Get full API documentation for all debugger service functions."""
+        return _get_skill_md_impl()
+
+
+_MODULES = {
+    "debugger": "hypha_debugger.debugger",
+    "services.execute": "hypha_debugger.services.execute",
+    "services.filesystem": "hypha_debugger.services.filesystem",
+    "services.info": "hypha_debugger.services.info",
+    "services.inspect_vars": "hypha_debugger.services.inspect_vars",
+    "services.source": "hypha_debugger.services.source",
+    "utils.env": "hypha_debugger.utils.env",
+}
+
+
+def _get_source_impl(module: str) -> dict:
+    if not module:
+        return {
+            "modules": list(_MODULES.keys()),
+            "hint": 'Pass a module name, e.g. get_source(module="services.execute")',
+        }
+
+    full_name = _MODULES.get(module)
+    if not full_name:
+        return {
+            "error": f"Unknown module: {module}",
+            "available": list(_MODULES.keys()),
+        }
+
+    try:
+        mod = __import__(full_name, fromlist=["_"])
+        source = inspect.getsource(mod)
+        return {
+            "module": module,
+            "full_name": full_name,
+            "source": source,
+            "lines": source.count("\n") + 1,
+        }
+    except Exception as e:
+        return {"error": f"Failed to get source: {e}"}
+
+
+def _get_skill_md_impl() -> str:
+    return """# Hypha Remote Debugger — Python Process API
+
+## Overview
+A debugger is attached to a running Python process. You can remotely execute code,
+read/write files, inspect variables, and query process info via the HTTP API.
+
+## Functions
+
+### get_process_info()
+Get information about the current Python process.
+- **Returns**: `{pid, cwd, python_version, hostname, platform, memory_mb, cpu_count, ...}`
+- **Example**: `curl "$SERVICE_URL/get_process_info"`
+
+### execute_code(code, namespace?, timeout?)
+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 `""`): Namespace. Empty = persistent REPL. `"__main__"` = main module.
+- **timeout** (int, default `30`): Timeout in seconds. 0 for no timeout.
+- **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" \\
+    -H "Content-Type: application/json" \\
+    -d '{"code": "import sys; sys.version"}'
+  ```
+
+### get_variable(name, namespace?)
+Inspect a variable by name.
+- **name** (string, required): Variable name.
+- **namespace** (string, default `"__main__"`): Module namespace.
+- **Returns**: `{name, type, repr, length?, shape?, dtype?, keys?}`
+
+### list_variables(namespace?, filter?, include_private?)
+List variables in a namespace.
+- **namespace** (string, default `"__main__"`): Module namespace.
+- **filter** (string): Substring filter for names.
+- **include_private** (bool, default `false`): Include `_`-prefixed names.
+- **Returns**: List of `{name, type, repr}`.
+
+### get_stack_trace()
+Get stack traces of all threads.
+- **Returns**: List of `{thread_id, thread_name, stack}`.
+- **Example**: `curl "$SERVICE_URL/get_stack_trace"`
+
+### list_files(path?, pattern?)
+List files and directories (sandboxed to CWD).
+- **path** (string, default `"."`): Directory path relative to CWD.
+- **pattern** (string): Glob filter, e.g. `"*.py"`.
+- **Returns**: `{path, entries: [{name, type, size?}], total}`
+- **Example**: `curl "$SERVICE_URL/list_files"`
+
+### read_file(path, max_lines?, offset?, encoding?)
+Read a file (sandboxed to CWD).
+- **path** (string, required): File path relative to CWD.
+- **max_lines** (int, default `500`): Max lines to read.
+- **offset** (int, default `0`): Lines to skip from beginning.
+- **Returns**: `{path, content, lines_read, offset, truncated}`
+- **Example**:
+  ```bash
+  curl -X POST "$SERVICE_URL/read_file" \\
+    -H "Content-Type: application/json" \\
+    -d '{"path": "main.py"}'
+  ```
+
+### write_file(path, content, mode?, create_dirs?, encoding?)
+Write content to a file (sandboxed to CWD).
+- **path** (string, required): File path relative to CWD.
+- **content** (string, required): Content to write.
+- **mode** (string, default `"w"`): `"w"` to overwrite, `"a"` to append.
+- **create_dirs** (bool, default `true`): Create parent directories.
+- **Returns**: `{path, bytes_written, mode}`
+- **Example**:
+  ```bash
+  curl -X POST "$SERVICE_URL/write_file" \\
+    -H "Content-Type: application/json" \\
+    -d '{"path": "hello.txt", "content": "Hello!"}'
+  ```
+
+### get_installed_packages(filter?)
+List installed pip packages.
+- **filter** (string): Substring filter for package names.
+- **Returns**: List of `{name, version}`.
+- **Example**: `curl "$SERVICE_URL/get_installed_packages"`
+
+### get_source(module?)
+Get the source code of debugger modules.
+- **module** (string): Module path, e.g. `"services.execute"`. Empty to list modules.
+- **Returns**: `{module, source, lines}` or `{modules, hint}`.
+
+### get_skill_md()
+Get this API documentation as Markdown.
+- **Returns**: This document as a string.
+- **Example**: `curl "$SERVICE_URL/get_skill_md"`
+
+## Notes
+- All file operations are sandboxed to the process CWD.
+- POST endpoints accept JSON body with parameter names as keys.
+- GET endpoints take no parameters (or use query params).
+- Code execution has a default 30s timeout to prevent hangs.
+"""

{hypha_debugger-0.1.5 → 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.5
+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.5 → hypha_debugger-0.1.7}/hypha_debugger.egg-info/SOURCES.txt

@@ -14,6 +14,7 @@ hypha_debugger/services/execute.py
 hypha_debugger/services/filesystem.py
 hypha_debugger/services/info.py
 hypha_debugger/services/inspect_vars.py
+hypha_debugger/services/source.py
 hypha_debugger/utils/__init__.py
 hypha_debugger/utils/env.py
 tests/test_services.py

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

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "hypha-debugger"
-version = "0.1.5"
+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.5 → 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():
@@ -225,6 +265,50 @@ def test_instruction_block_with_token():
     assert "Authorization" in block
 
 
+# --- source ---
+
+def test_get_source_list_modules():
+    from hypha_debugger.services.source import get_source
+    result = get_source("")
+    assert "modules" in result
+    assert "services.execute" in result["modules"]
+    assert "services.filesystem" in result["modules"]
+    assert "debugger" in result["modules"]
+
+
+def test_get_source_module():
+    from hypha_debugger.services.source import get_source
+    result = get_source("services.execute")
+    assert "source" in result
+    assert "execute_code" in result["source"]
+    assert result["lines"] > 10
+
+
+def test_get_source_unknown():
+    from hypha_debugger.services.source import get_source
+    result = get_source("nonexistent")
+    assert "error" in result
+    assert "available" in result
+
+
+def test_get_skill_md():
+    from hypha_debugger.services.source import get_skill_md
+    md = get_skill_md()
+    assert isinstance(md, str)
+    assert "execute_code" in md
+    assert "write_file" in md
+    assert "get_source" in md
+    assert "get_skill_md" in md
+    assert "SERVICE_URL" in md
+
+
+def test_instruction_block_includes_new_functions():
+    from hypha_debugger.debugger import _build_instruction_block
+    block = _build_instruction_block("https://example.com/ws/services/py-debugger-abc")
+    assert "get_source" in block
+    assert "get_skill_md" in block
+
+
 def test_debug_session_print_instructions(capsys):
     from hypha_debugger.debugger import DebugSession
     session = DebugSession(

hypha_debugger-0.1.5/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__}>"